死锁

现代的计算机伴随着多核 CPU 的出现，不同的线程能在不同的 CPU 核并行执行。而多线程是在同一个程序内部并行执行，因此会对相同的内存空间进行并发读写操作。

这可能出现某些无法预测的问题。就像，如果两个线程同时写入同一个内存，那在操作完成后将会是什么结果？是第一个线程写入的值？还是第二个线程写入的值？或是两者兼具？

如果一个线程在读一个内存时，另一个线程正向该内存进行写操作，那又会怎样呢？是写操作之前旧的值？还是写操作成功之后的新值？

因此如没有合适的预防措施，任何结果都是可能的。而且这种行为的发生甚至不能预测，所以结果也是不确定性的。

---

死锁

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。

线程 A 占有资源 R，请求资源 S。线程 B 占有资源 S，请求资源 R。线程 A 和 B 都会因为请求不到自己的资源而阻塞。这就是死锁。

死锁视图.jpg

可以形象的看作：

小猫追尾巴，转圈圈。

死锁产生的条件：

• 互斥条件：每个资源要么已经分配给一个进程，要么是可用的。

• 占有和等待条件:已经占有资源的进程可以申请其他资源。

• 不可抢占条件：已经被占有的资源不能被其他的进程抢占， 只有占有它的进程才能显示释放。

• 环路等待条件：死锁发生时，系统中有两个或两个以上的进程一条环路，该环路中的每一个进程都在等待下一个进程所占有的资源。

死锁发生时，以上的四个条件必须同时满足，如果有其中的一个条件不满足，死锁就不会发生。

---

这里有一个 LockTest 类的例子，它调用了不同实例的 synchronized 方法：

public class LockTest {
   public static String obj1 = "R";
   public static String obj2 = "S";
   public static void main(String[] args) {
      LockA la = new LockA();
      new Thread(la).start();
      LockB lb = new LockB();
      new Thread(lb).start();
   }
}
class LockA implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockA 开始执行");
         while(true){
            synchronized (LockTest.obj1) {
               System.out.println(new Date().toString() + " LockA 锁住 R");
               Thread.sleep(3000); // 此处等待是给B能锁住机会
               synchronized (LockTest.obj2) {
                  System.out.println(new Date().toString() + " LockA 锁住 S");
                  Thread.sleep(60 * 1000); // 为测试，占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}
class LockB implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockB 开始执行");
         while(true){
            synchronized (LockTest.obj2) {
               System.out.println(new Date().toString() + " LockB 锁住S");
               Thread.sleep(3000); // 此处等待是给A能锁住机会
               synchronized (LockTest.obj1) {
                  System.out.println(new Date().toString() + " LockB R");
                  Thread.sleep(60 * 1000); // 为测试，占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

输出结果：

Thu Apr 06 23:14:10 GMT+08:00 2017 LockB 开始执行
Thu Apr 06 23:14:10 GMT+08:00 2017 LockB 锁住S
Thu Apr 06 23:14:10 GMT+08:00 2017 LockA 开始执行
Thu Apr 06 23:14:10 GMT+08:00 2017 LockA 锁住 R

如果线程 A 调用 Runnable（） 方法的同时有另外一个线程 B 调用 Runnable（） 方法，两个线程相互锁住资源不放，此时就会发生死锁。下面的伪代码说明了这个过程：

Thread A:synchronized (LockTest.obj1); //locks R
--> synchronized (LockTest.obj1);

Thread B: synchronized (LockTest.obj1); //locks S
--> synchronized (LockTest.obj1)

首先线程 A 调用 start（）方法。因为 LockTest.obj1 是同步的，所以线程 A 会对 obj1 对象（资源 R）加锁以不让其它线程访问该对象。

然后线程 B 调用 start（）方法。因为 LockTest.obj2 也是同步的，所以线程 B 会对 obj2 对象（资源 S）加锁以不让其它线程访问该对象。

现在 obj1 和 obj2 对象被两个不同的线程锁住了。接下来线程 A 尝试请求资源 S，但是由于 obj2 对象现在被线程 B 锁住的，所以该调用会被阻塞。线程 B 也尝试请求资源 R，但是由于 obj1 对象现在被线程 A 锁住，导致线程 B 也阻塞在该方法处。现在两个线程都被阻塞并等待着获取另外一个线程所持有的锁。

正常而言，上面的代码可能运行一段时间才会出现死锁。故而，在代码中让线程等待以给另一个线程锁住资源的机会。

这些线程需要同时获得锁。举个例子，如果线程 A 稍微领先线程 B，然后成功地锁住了 R 和 S 两个对象，那么线程 B 就会在尝试对 S 加锁的时候被阻塞，这样死锁就不会发生。因为线程调度通常是不可预测的，因此没有一个办法可以准确预测什么时候死锁会发生，仅仅是可能会发生。