死锁的三种形式：一般死锁，嵌套管程锁死，重入锁死

死锁的定义：

死锁一般是指两个（或两个以上）线程同时竞争两个（或者多个）资源，从而产生同时等待的现象，使得系统僵持不动。

顺便复习一下线程与进程的定义以及他们之间的区别。

进程：一个有独立功能的程序利用某些数据资源的一次远行过程。

线程：一个进程里面的一条执行路径（或者执行过程），同一条进程下的n多条线程之间可以互相通信（共享数据）。

区别：进程是相对独立的单位， 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程

只是一个进程中的不同执行路径。 线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，

一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，

耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，

只能用线程，不能用进程。

总之：进程是相对独立的，一个进程的崩溃不会影响到其他进程，但是一个线程必须依赖于进程的存在而存在，

线程之间可以共享数据。

一般死锁产生的示例图：

1、一般的死锁

一般的死锁是指多个线程的执行必须同时拥有多个资源，由于不同的线程需要的资源被不同的线程占用，最终导致僵持的状态，这就是一般死锁的定义。

package com.cxt.thread;public class TestDeadLock extends Thread{  boolean b;  DeadLock lock;  public TestDeadLock(boolean b, DeadLock lock) {    super();    this.b = b;    this.lock = lock;  }  public static void main(String[] args) {    DeadLock lock = new DeadLock();    TestDeadLock t1 = new TestDeadLock(true, lock);    TestDeadLock t2 = new TestDeadLock(false, lock);    t1.start();    t2.start();  }  @Override  public void run() {    if(this.b){      lock.m1();    }    else      lock.m2();  }  }class DeadLock {  Object o1 = new Object();  Object o2 = new Object();    void m1(){    synchronized(o1){      System.out.println("m1 Lock o1 first");      synchronized(o2){        System.out.println("m1 Lock o2 second");      }    }  }  void m2(){    synchronized(o2){      System.out.println("m2 Lock o2 first");      synchronized(o1){        System.out.println("m2 Lock o1 second");      }    }  }}

如代码所示我们可知：线程t1,t2都需要对象o1,o2才能正常地完成功能，但是由于他们所持的对象与要获得的对象刚好相反，使得两条线程一直僵持，

最终导致死锁。

解决方法：等其中一条线程完全执行完之后再执行另外一条线程。

推广到多条线程，按一定的顺序执行多条线程。

另外一种方法就是设置优先级，如果运行多条线程出现死锁，优先级低的回退，优先级高的先执行这样即可解决死锁问题。

2、嵌套管程锁死

线程1获得A对象的锁。线程1获得对象B的锁（同时持有对象A的锁）。线程1决定等待另一个线程的信号再继续。线程1调用B.wait()，从而释放了B对象上的锁，但仍然持有对象A的锁。线程2需要同时持有对象A和对象B的锁，才能向线程1发信号。线程2无法获得对象A上的锁，因为对象A上的锁当前正被线程1持有。线程2一直被阻塞，等待线程1释放对象A上的锁。线程1一直阻塞，等待线程2的信号，因此，不会释放对象A上的锁，  而线程2需要对象A上的锁才能给线程1发信号……

看代码：

package com.cxt.Lock;import com.cxt.thread.Synchronizer;import com.cxt.thread.TestLock;//lock implementation with nested monitor lockout problem/** * 一个坑爹的嵌套管程锁死，区别于死锁 */public class Lock {  protected MonitorObject monitorObject = new MonitorObject();  protected boolean isLocked = false;  public static void main(String[] args) {    Lock l = new Lock();    l.isLocked = true;    MyRunnable r1 = new MyRunnable(l, 0);    MyRunnable r2 = new MyRunnable(l, 0);    Thread t1 = new Thread(r1);    Thread t2 = new Thread(r2);    t1.start();    t2.start();    /*     * 時而鎖住，時而釋放，因為另外兩條線程沒有有时捕捉不到isLocked = false     *///for (int i = 0; i < 100; i++) {//l.isLocked = false;//try {//Thread.sleep(10);//} catch (InterruptedException e) {//e.printStackTrace();//}//}    //  }  public void lock() throws InterruptedException {    // 当执行这个方法时，isLocked=true时,其他方法无论执行lock方法还是执行Unlock方法都会导致管程死锁    // 只有手动将isLocked 设置为false才能解决死锁，设置为false时必须让其他线程检测到，所以必须设置时间长一点    synchronized (this) {      while (isLocked) {        synchronized (this.monitorObject) {          this.monitorObject.wait();        }      }      isLocked = true;    }  }  public void unlock() {    synchronized (this) {      this.isLocked = false;      synchronized (this.monitorObject) {        this.monitorObject.notify();      }    }  }  static class MyRunnable implements Runnable {    Lock l = null;    int i;    public MyRunnable(Lock l, int i) {      this.l = l;      this.i = i;    }    @Override    public void run() {      try {        if (i % 2 == 0) {          this.l.lock();        } else {          this.l.unlock();        }      } catch (InterruptedException e) {        e.printStackTrace();      }    }  }}

我们观察lock()方法,执行lock（）时，当isLocked 为true时，问题就来了，执行monitorObject的方法块，

但是monitorObject变成了等待状态，但是这是外面的this锁还是被此线程持有的，如果有其他线程要执行lock（）

或者unLock（）,此时都会产生无限等待的状态，此线程也因此永远处于无限带等待其他线程来唤醒monitorObject的状态，

最终就一直僵持着。

解决方法手动将isLocked设为false.

这一种较坑，编代码时别没事找事做。

3、重入锁死

package com.cxt.Lock;public class Lock2{  private boolean isLocked = false;    public static void main(String[] args) {    Lock2 lock = new Lock2();        MyRunnable r1 = new MyRunnable(lock, true);    MyRunnable r2 = new MyRunnable(lock, false);    Thread t1 = new Thread(r1);    Thread t2 = new Thread(r2);    t1.start();    //t2.start();  }  public synchronized void lock()    throws InterruptedException{    while(isLocked){      wait();    }    isLocked = true;  }  public synchronized void unlock(){    isLocked = false;    notify();  }    static class MyRunnable implements Runnable{    Lock2 l = null;    boolean flag = false;    public MyRunnable(Lock2 l, boolean flag) {      this.l = l;      this.flag = flag;    }    @Override    public void run() {      if(flag == true)        try {//如果连续执行两次lock(),就会产生系统无限等待的状态//解决方法就是在两次中间执行一次unLock()方法          l.lock();          System.out.println("Lock!");//l.unlock();//System.out.println("Unlock!");          l.lock();          System.out.println("Lock!");        } catch (InterruptedException e) {          e.printStackTrace();        }      else         l.unlock();    }      }}

当连续执行两次lock()时会出现：

第一次，isLocked为false，执行完把isLocked设为true.

第二次，isLocked为true，此时就会处于无限等待的状态。

解决方法，两个lock（）中间执行一次unLock方法，或者由另外一条线程来执行一次unLock（）方法。

重入的概念： 如果一个线程持有某个管程对象上的锁，那么它就有权访问所有在该管程对象上同步的块。这就叫可重入。若线程已经持有锁，那么它就可以重复访问所有使用该锁的代码块。

显然这个例子是不可以重入的！