Java 语言通过 synchronized 关键字来保证原子性，这是因为每一个 Object 都有一个隐含的锁，这个也称作监视器对象。在进入 synchronized 之前自动获取此内部锁，而一旦离开此方式，无论是完成或者中断都会自动释放锁。显然这是一个独占锁，每个锁请求之间是互斥的。相对于众多高级锁 (Lock/ReadWriteLock 等)，synchronized 的代价都比后者要高。但是 synchronzied 的语法比较简单，而且也比较容易使用和理解。Lock 一旦调用了 lock() 方法获取到锁而未正确释放的话很有可能造成死锁，所以 Lock 的释放操作总是跟在 finally 代码块里面，这在代码结构上也是一次调整和冗余。Lock 的实现已经将硬件资源用到了极致，所以未来可优化的空间不大，除非硬件有了更高的性能，但是 synchronized 只是规范的一种实现，这在不同的平台不同的硬件还有很高的提升空间，未来 Java 锁上的优化也会主要在这上面。既然 synchronzied 都不可能避免死锁产生，那么死锁情况会是经常容易出现的错误，下面具体描述死锁发生的原因及解决方法。

死锁描述

死锁是操作系统层面的一个错误，是进程死锁的简称，最早在 1965 年由 Dijkstra 在研究银行家算法时提出的，它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。

事实上，计算机世界有很多事情需要多线程方式去解决，因为这样才能最大程度上利用资源，才能体现出计算的高效。但是，实际上来说，计算机系统中有很多一次只能由一个进程使用的资源的情况，例如打印机，同时只能有一个进程控制它。在多通道程序设计环境中，若干进程往往要共享这类资源，而且一个进程所需要的资源还很有可能不止一个。因此，就会出现若干进程竞争有限资源，又推进顺序不当，从而构成无限期循环等待的局面。我们称这种状态为死锁。简单一点描述，死锁是指多个进程循环等待它方占有的资源而无限期地僵持下去的局面。很显然，如果没有外力的作用，那么死锁涉及到的各个进程都将永远处于封锁状态。

系统发生死锁现象不仅浪费大量的系统资源，甚至导致整个系统崩溃，带来灾难性后果。所以，对于死锁问题在理论上和技术上都必须予以高度重视。

银行家算法

一个银行家如何将一定数目的资金安全地借给若干个客户，使这些客户既能借到钱完成要干的事，同时银行家又能收回全部资金而不至于破产。银行家就像一个操作系统，客户就像运行的进程，银行家的资金就是系统的资源。

银行家算法需要确保以下四点：

  • 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客
  • 顾客可以分期贷款, 但贷款的总数不能超过最大需求量
  • 当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可- 推迟支付，但总能使顾客在有限的时间里得到贷款
  • 当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金

清单 1. 银行家算法实现

  1. /*一共有５个进程需要请求资源，有３类资源*/
  2. public class BankDemo {
  3.     /* 每个进程所需要的最大资源数 */
  4.     public static int MAX[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 },
  5.                       { 2, 2, 2 }, { 4, 3, 3 } };
  6.     /* 系统拥有的初始资源数 */
  7.     public static int AVAILABLE[] = { 10, 5, 7 };
  8.     /* 系统已给每个进程分配的资源数 */
  9.     public static int ALLOCATION[][] = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
  10.                          { 0, 0, 0 }, { 0, 0, 0 } };
  11.     /* 每个进程还需要的资源数 */
  12.     public static int NEED[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 },
  13.                        { 2, 2, 2 }, { 4, 3, 3 } };
  14.     /* 每次申请的资源数 */
  15.     public static int Request[] = { 0, 0, 0 };
  16.     /* 进程数与资源数 */
  17.     public static int    M    = 5, N = 3;
  18.     int            FALSE    = 0;
  19.     int            TRUE    = 1;
  20.     public void showdata()
  21.     {
  22.         int i, j;
  23.         System.out.print( "系统可用的资源数为:/n" );
  24.         for ( j = 0; j < N; j++ )
  25.         {
  26.             System.out.print( "资源" + j + ":" + AVAILABLE[j] + " " );
  27.         }
  28.         System.out.println();
  29.         System.out.println( "各进程还需要的资源量:" );
  30.         for ( i = 0; i < M; i++ )
  31.         {
  32.             System.out.print( "进程" + i + ":" );
  33.             for ( j = 0; j < N; j++ )
  34.             {
  35.                 System.out.print( "资源" + j + ":" + NEED[i][j] + " " );
  36.             }
  37.             System.out.print( "/n" );
  38.         }
  39.         System.out.print( "各进程已经得到的资源量: /n" );
  40.         for ( i = 0; i < M; i++ )
  41.         {
  42.             System.out.print( "进程" );
  43.             System.out.print( i );
  44.             for ( j = 0; j < N; j++ )
  45.             {
  46.                 System.out.print( "资源" + j + ":" + ALLOCATION[i][j] + " " );
  47.             }
  48.             System.out.print( "/n" );
  49.         }
  50.     }
  53.     /* 分配资源，并重新更新各种状态 */
  54.     public void changdata( int k )
  55.     {
  56.         int j;
  57.         for ( j = 0; j < N; j++ )
  58.         {
  59.             AVAILABLE[j]        = AVAILABLE[j] - Request[j];
  60.             ALLOCATION[k][j]    = ALLOCATION[k][j] + Request[j];
  61.             NEED[k][j]        = NEED[k][j] - Request[j];
  62.         }
  63.     };
  64.     /* 回收资源，并重新更新各种状态 */
  65.     public void rstordata( int k )
  66.     {
  67.         int j;
  68.         for ( j = 0; j < N; j++ )
  69.         {
  70.             AVAILABLE[j]        = AVAILABLE[j] + Request[j];
  71.             ALLOCATION[k][j]    = ALLOCATION[k][j] - Request[j];
  72.             NEED[k][j]        = NEED[k][j] + Request[j];
  73.         }
  74.     };
  75.     /* 释放资源 */
  76.     public void free( int k )
  77.     {
  78.         for ( int j = 0; j < N; j++ )
  79.         {
  80.             AVAILABLE[j] = AVAILABLE[j] + ALLOCATION[k][j];
  81.             System.out.print( "释放" + k + "号进程的" + j + "资源!/n" );
  82.         }
  83.     }
  86.     public int check0( int k )
  87.     {
  88.         int j, n = 0;
  89.         for ( j = 0; j < N; j++ )
  90.         {
  91.             if ( NEED[k][j] == 0 )
  92.                 n++;
  93.         }
  94.         if ( n == 3 )
  95.             return(1);
  96.         else
  97.             return(0);
  98.     }
  101.     /*
  102.      * 检查安全性函数
  103.      * 所以银行家算法其核心是：保证银行家系统的资源数至少不小于一个客户的所需要的资源数。在安全性检查函数 chkerr() 上由这个方法来实现
  104.      * 这个循环来进行核心判断，从而完成了银行家算法的安全性检查工作。
  105.      */
  106.     public int chkerr( int s )
  107.     {
  108.         int    WORK;
  109.         int    FINISH[] = new int[M], temp[] = new int[M];     /* 保存临时的安全进程序列 */
  110.         int    i, j, k = 0;
  111.         for ( i = 0; i < M; i++ )
  112.             FINISH[i] = FALSE;
  113.         for ( j = 0; j < N; j++ )
  114.         {
  115.             WORK    = AVAILABLE[j];                         /* 第 j 个资源可用数 */
  116.             i    = s;
  117.             /* 判断第 i 个进程是否满足条件 */
  118.             while ( i < M )
  119.             {
  120.                 if ( FINISH[i] == FALSE && NEED[i][j] <= WORK )
  121.                 {
  122.                     WORK        = WORK + ALLOCATION[i][j];
  123.                     FINISH[i]    = TRUE;
  124.                     temp[k]        = i;
  125.                     k++;
  126.                     i = 0;
  127.                 } else {
  128.                     i++;
  129.                 }
  130.             }
  131.             for ( i = 0; i < M; i++ )
  132.                 if ( FINISH[i] == FALSE )
  133.                 {
  134.                     System.out.print( "/n 系统不安全!!! 本次资源申请不成功!/n" );
  135.                     return(1);
  136.                 }
  137.         }
  138.         System.out.print( "/n 经安全性检查，系统安全，本次分配成功。/n" );
  139.         System.out.print( "本次安全序列：" );
  140.         for ( i = 0; i < M - 1; i++ )
  141.         {
  142.             System.out.print( "进程" + temp[i] + "->" );
  143.         }
  144.         System.out.print( "进程" + temp[M - 1] );
  145.         System.out.println( "/n" );
  146.         return(0);
  147.     }
  148. }

死锁示例

死锁问题是多线程特有的问题，它可以被认为是线程间切换消耗系统性能的一种极端情况。在死锁时，线程间相互等待资源，而又不释放自身的资源，导致无穷无尽的等待，其结果是系统任务永远无法执行完成。死锁问题是在多线程开发中应该坚决避免和杜绝的问题。

一般来说，要出现死锁问题需要满足以下条件：

  1. 互斥条件：一个资源每次只能被一个线程使用。
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

只要破坏死锁 4 个必要条件之一中的任何一个，死锁问题就能被解决。

我们先来看一个示例，前面说过，死锁是两个甚至多个线程被永久阻塞时的一种运行局面，这种局面的生成伴随着至少两个线程和两个或者多个资源。代码清单 2 所示的示例中，我们编写了一个简单的程序，它将会引起死锁发生，然后我们就会明白如何分析它。

清单 2. 死锁示例

  1. public class ThreadDeadlock {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         Object obj1 = new Object();
  4.         Object obj2 = new Object();
  5.         Object obj3 = new Object();
  7.         Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1");
  8.         Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2");
  9.         Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3");
  11.         t1.start();
  12.         Thread.sleep(5000);
  13.         t2.start();
  14.         Thread.sleep(5000);
  15.         t3.start();
  16.     }
  17. }
  1. class SyncThread implements Runnable {
  2.     private Object obj1;
  3.     private Object obj2;
  5.     public SyncThread(Object o1, Object o2) {
  6.         this.obj1 = o1;
  7.         this.obj2 = o2;
  8.     }
  10.     @Override
  11.     public void run() {
  12.         String name = Thread.currentThread().getName();
  13.         System.out.println(name + " acquiring lock on " + obj1);
  15.         synchronized (obj1) {
  16.             System.out.println(name + " acquired lock on " + obj1);
  17.             work();
  18.             System.out.println(name + " acquiring lock on " + obj2);
  20.             synchronized (obj2) {
  21.                 System.out.println(name + " acquired lock on " + obj2);
  22.                 work();
  23.             }
  25.             System.out.println(name + " released lock on " + obj2);
  26.         }
  28.         System.out.println(name + " released lock on " + obj1);
  29.         System.out.println(name + " finished execution.");
  30.     }
  32.     private void work() {
  33.         try {
  34.             Thread.sleep(30000);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

在上面的程序中同步线程正完成 Runnable 的接口，它工作的是两个对象，这两个对象向对方寻求死锁而且都在使用同步阻塞。在主函数中，我使用了三个为同步线程运行的线程，而且在其中每个线程中都有一个可共享的资源。这些线程以向第一个对象获取封锁这种方式运行。但是当它试着向第二个对象获取封锁时，它就会进入等待状态，因为它已经被另一个线程封锁住了。这样，在线程引起死锁的过程中，就形成了一个依赖于资源的循环。当我执行上面的程序时，就产生了输出，但是程序却因为死锁无法停止。输出如清单 3 所示。

清单 3. 清单 2 运行输出

  1. t1 acquiring lock on java.lang.Object@1dd3812
  2. t1 acquired lock on java.lang.Object@1dd3812
  3. t2 acquiring lock on java.lang.Object@c791b9
  4. t2 acquired lock on java.lang.Object@c791b9
  5. t3 acquiring lock on java.lang.Object@1aa9f99
  6. t3 acquired lock on java.lang.Object@1aa9f99
  7. t1 acquiring lock on java.lang.Object@c791b9
  8. t2 acquiring lock on java.lang.Object@1aa9f99

在此我们可以清楚地在输出结果中辨认出死锁局面，但是在我们实际所用的应用中，发现死锁并将它排除是非常难的。
死锁情况诊断

JVM 提供了一些工具可以来帮助诊断死锁的发生，如下面程序清单 4 所示，我们实现了一个死锁，然后尝试通过 jstack 命令追踪、分析死锁发生。
清单 4. 死锁代码

  1. import java.util.concurrent.locks.ReentrantLock;
  3. //下面演示一个简单的死锁，两个线程分别占用 south 锁和 north 锁，并同时请求对方占用的锁，导致死锁
  4. public class DeadLock extends Thread {
  5.     static ReentrantLock south = new ReentrantLock();
  6.     static ReentrantLock north = new ReentrantLock();
  7.     protected Object myDirect;
  9.     public DeadLock(Object obj) {
  10.         this.myDirect = obj;
  12.         if (myDirect == south) {
  13.             this.setName("south");
  14.         } else {
  15.             this.setName("north");
  16.         }
  17.     }
  19.     @Override
  20.     public void run() {
  21.         if (myDirect == south) {
  22.             try {
  23.                 north.lockInterruptibly(); //?? north
  25.                 try {
  26.                     Thread.sleep(500);
  27.                 } catch (Exception ex) {
  28.                     ex.printStackTrace();
  29.                 }
  31.                 south.lockInterruptibly();
  32.                 System.out.println("car to south has passed");
  33.             } catch (InterruptedException ex) {
  34.                 System.out.println("car to south is killed");
  35.                 ex.printStackTrace();
  36.             } finally {
  37.                 if (north.isHeldByCurrentThread()) {
  38.                     north.unlock();
  39.                 }
  41.                 if (south.isHeldByCurrentThread()) {
  42.                     south.unlock();
  43.                 }
  44.             }
  45.         }
  47.         if (myDirect == north) {
  48.             try {
  49.                 south.lockInterruptibly(); //?? south
  51.                 try {
  52.                     Thread.sleep(500);
  53.                 } catch (Exception ex) {
  54.                     ex.printStackTrace();
  55.                 }
  57.                 north.lockInterruptibly();
  58.                 System.out.println("car to north has passed");
  59.             } catch (InterruptedException ex) {
  60.                 System.out.println("car to north is killed");
  61.                 ex.printStackTrace();
  62.             } finally {
  63.                 if (north.isHeldByCurrentThread()) {
  64.                     north.unlock();
  65.                 }
  67.                 if (south.isHeldByCurrentThread()) {
  68.                     south.unlock();
  69.                 }
  70.             }
  71.         }
  72.     }
  74.     public static void main(String[] args) throws InterruptedException {
  75.         DeadLock car2south = new DeadLock(south);
  76.         DeadLock car2north = new DeadLock(north);
  77.         car2south.start();
  78.         car2north.start();
  79.     }
  80. }

jstack 可用于导出 Java 应用程序的线程堆栈，-l 选项用于打印锁的附加信息。我们运行 jstack 命令，输出入清单 5 和 6 所示，其中清单 5 里面可以看到线程处于运行状态，代码中调用了拥有锁投票、定时锁等候和可中断锁等候等特性的 ReentrantLock 锁机制。清单 6 直接打印出出现死锁情况，报告 north 和 sourth 两个线程互相等待资源，出现了死锁。

清单 5. jstack 运行输出 1

  1. [root@facenode4 ~]# jstack -l 31274
  2. 2015-01-29 12:40:27
  3. Full thread dump Java HotSpot(TM) 64-Bit Server VM (20.45-b01 mixed mode):
  5. "Attach Listener" daemon prio=10 tid=0x00007f6d3c001000 nid=
  6.             0x7a87 waiting on condition [0x0000000000000000]
  7.  java.lang.Thread.State: RUNNABLE
  9.  Locked ownable synchronizers:
  10.  - None
  12. "DestroyJavaVM" prio=10 tid=0x00007f6da4006800 nid=
  13.             0x7a2b waiting on condition [0x0000000000000000]
  14.  java.lang.Thread.State: RUNNABLE
  16.  Locked ownable synchronizers:
  17.  - None
  19. "north" prio=10 tid=0x00007f6da4101800 nid=
  20.             0x7a47 waiting on condition [0x00007f6d8963b000]
  21.  java.lang.Thread.State: WAITING (parking)
  22.  at sun.misc.Unsafe.park(Native Method)
  23.  - parking to wait for <0x000000075903c7c8> (
  24.                             a java.util.concurrent.locks.ReentrantLock$NonfairSync)
  25.  at java.util.concurrent.locks.LockSupport.park(LockSupport.java:156)
  26.  at java.util.concurrent.locks.AbstractQueuedSynchronizer.
  27.                             parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:811)
  28.  at java.util.concurrent.locks.AbstractQueuedSynchronizer.
  29.                             doAcquireInterruptibly(AbstractQueuedSynchronizer.java:867)
  30.  at java.util.concurrent.locks.AbstractQueuedSynchronizer.
  31.                             acquireInterruptibly(AbstractQueuedSynchronizer.java:1201)
  32.  at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:312)
  33.  at DeadLock.run(DeadLock.java:50)
  35.  Locked ownable synchronizers:
  36.  - <0x000000075903c798> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
  38. "south" prio=10 tid=0x00007f6da4100000 nid=
  39.                         0x7a46 waiting on condition [0x00007f6d8973c000]
  40.  java.lang.Thread.State: WAITING (parking)
  41.  at sun.misc.Unsafe.park(Native Method)
  42.  - parking to wait for <0x000000075903c798> (
  43.                                         a java.util.concurrent.locks.ReentrantLock$NonfairSync)
  44.  at java.util.concurrent.locks.LockSupport.park(LockSupport.java:156)
  45.  at java.util.concurrent.locks.AbstractQueuedSynchronizer.
  46.                                     parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:811)
  47.  at java.util.concurrent.locks.AbstractQueuedSynchronizer.
  48.                                     doAcquireInterruptibly(AbstractQueuedSynchronizer.java:867)
  49.  at java.util.concurrent.locks.AbstractQueuedSynchronizer.
  50.                                      acquireInterruptibly(AbstractQueuedSynchronizer.java:1201)
  51.  at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:312)
  52.  at DeadLock.run(DeadLock.java:28)
  54.  Locked ownable synchronizers:
  55.  - <0x000000075903c7c8> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
  57. "Low Memory Detector" daemon prio=10 tid=0x00007f6da40d2800 nid=
  58.                                     0x7a44 runnable [0x0000000000000000]
  59.  java.lang.Thread.State: RUNNABLE
  61.  Locked ownable synchronizers:
  62.  - None
  64. "C2 CompilerThread1" daemon prio=10 tid=0x00007f6da40d0000 nid=
  65.                                     0x7a43 waiting on condition [0x0000000000000000]
  66.  java.lang.Thread.State: RUNNABLE
  68.  Locked ownable synchronizers:
  69.  - None
  71. "C2 CompilerThread0" daemon prio=10 tid=0x00007f6da40cd000 nid=
  72.                                     0x7a42 waiting on condition [0x0000000000000000]
  73.  java.lang.Thread.State: RUNNABLE
  75.  Locked ownable synchronizers:
  76.  - None
  78. "Signal Dispatcher" daemon prio=10 tid=0x00007f6da40cb000 nid=
  79.                                     0x7a41 runnable [0x0000000000000000]
  80.  java.lang.Thread.State: RUNNABLE
  82.  Locked ownable synchronizers:
  83.  - None
  85. "Finalizer" daemon prio=10 tid=0x00007f6da40af000 nid=
  86.                                       0x7a40 in Object.wait() [0x00007f6d89d44000]
  87.  java.lang.Thread.State: WAITING (on object monitor)
  88.  at java.lang.Object.wait(Native Method)
  89.  - waiting on <0x0000000759001300> (a java.lang.ref.ReferenceQueue$Lock)
  90.  at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118)
  91.  - locked <0x0000000759001300> (a java.lang.ref.ReferenceQueue$Lock)
  92.  at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:134)
  93.  at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:171)
  95.  Locked ownable synchronizers:
  96.  - None
  98. "Reference Handler" daemon prio=10 tid=0x00007f6da40ad000 nid=
  99.                                        0x7a3f in Object.wait() [0x00007f6d89e45000]
  100.  java.lang.Thread.State: WAITING (on object monitor)
  101.  at java.lang.Object.wait(Native Method)
  102.  - waiting on <0x00000007590011d8> (a java.lang.ref.Reference$Lock)
  103.  at java.lang.Object.wait(Object.java:485)
  104.  at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)
  105.  - locked <0x00000007590011d8> (a java.lang.ref.Reference$Lock)
  107.  Locked ownable synchronizers:
  108.  - None
  110. "VM Thread" prio=10 tid=0x00007f6da40a6000 nid=0x7a3e runnable 
  112. "GC task thread#0 (ParallelGC)" prio=10 tid=0x00007f6da4019800 nid=0x7a2c runnable 
  114. "GC task thread#1 (ParallelGC)" prio=10 tid=0x00007f6da401b000 nid=0x7a2d runnable 
  116. "GC task thread#2 (ParallelGC)" prio=10 tid=0x00007f6da401d000 nid=0x7a2e runnable 
  118. "GC task thread#3 (ParallelGC)" prio=10 tid=0x00007f6da401f000 nid=0x7a2f runnable 
  120. "GC task thread#4 (ParallelGC)" prio=10 tid=0x00007f6da4020800 nid=0x7a30 runnable 
  122. "GC task thread#5 (ParallelGC)" prio=10 tid=0x00007f6da4022800 nid=0x7a31 runnable 
  124. "GC task thread#6 (ParallelGC)" prio=10 tid=0x00007f6da4024800 nid=0x7a32 runnable 
  126. "GC task thread#7 (ParallelGC)" prio=10 tid=0x00007f6da4026000 nid=0x7a33 runnable 
  128. "GC task thread#8 (ParallelGC)" prio=10 tid=0x00007f6da4028000 nid=0x7a34 runnable 
  130. "GC task thread#9 (ParallelGC)" prio=10 tid=0x00007f6da402a000 nid=0x7a35 runnable 
  132. "GC task thread#10 (ParallelGC)" prio=10 tid=0x00007f6da402b800 nid=0x7a36 runnable 
  134. "GC task thread#11 (ParallelGC)" prio=10 tid=0x00007f6da402d800 nid=0x7a37 runnable 
  136. "GC task thread#12 (ParallelGC)" prio=10 tid=0x00007f6da402f800 nid=0x7a38 runnable 
  138. "GC task thread#13 (ParallelGC)" prio=10 tid=0x00007f6da4031000 nid=0x7a39 runnable 
  140. "GC task thread#14 (ParallelGC)" prio=10 tid=0x00007f6da4033000 nid=0x7a3a runnable 
  142. "GC task thread#15 (ParallelGC)" prio=10 tid=0x00007f6da4035000 nid=0x7a3b runnable 
  144. "GC task thread#16 (ParallelGC)" prio=10 tid=0x00007f6da4036800 nid=0x7a3c runnable 
  146. "GC task thread#17 (ParallelGC)" prio=10 tid=0x00007f6da4038800 nid=0x7a3d runnable 
  148. "VM Periodic Task Thread" prio=10 tid=0x00007f6da40dd000 nid=0x7a45 waiting on condition 
  150. JNI global references: 886
  152. 清单 6. jstack 运行输出片段 2
  153. WAITING FOR THIS LOCK TO BE GRANTED:
  154. RECORD LOCKS space id 0 page no 843102 n bits 600 index `KEY_TSKTASK_MONTIME2` of table
  155.         `dcnet_db/TSK_TASK` trx id 0 677833454 lock_mode X locks rec but not gap waiting
  156. Record lock, heap no 395 PHYSICAL RECORD: n_fields 3; compact format; info bits 0
  157. 0: len 8; hex 8000000000000425; asc %;; 1: len 8; hex 800012412c66d29c; 
  158.                     asc A,f ;; 2: len 8; hex 800000000097629c; asc b ;;
  160. *** WE ROLL BACK TRANSACTION (1)

我们假设涉事的数据表上面有一个索引，这次的死锁就是由于两条记录同时访问到了相同的索引造成的。

我们首先来看看 InnoDB 类型的数据表，只要能够解决索引问题，就可以解决死锁问题。MySQL 的 InnoDB 引擎是行级锁，需要注意的是，这不是对记录进行锁定，而是对索引进行锁定。在 UPDATE、DELETE 操作时，MySQL 不仅锁定 WHERE 条件扫描过的所有索引记录，而且会锁定相邻的键值，即所谓的 next-key locking；

如语句 UPDATE TSK_TASK SET UPDATE_TIME = NOW() WHERE ID > 10000 会锁定所有主键大于等于 1000 的所有记录，在该语句完成之前，你就不能对主键等于 10000 的记录进行操作；当非簇索引 (non-cluster index) 记录被锁定时，相关的簇索引 (cluster index) 记录也需要被锁定才能完成相应的操作。

再分析一下发生问题的两条 SQL 语句：
当“update TSK_TASK set STATUS_ID=1064,UPDATE_TIME=now () where STATUS_ID=1061 and MON_TIME<date_sub(now(), INTERVAL 30 minute)”执行时，MySQL 会使用 KEY_TSKTASK_MONTIME2 索引，因此首先锁定相关的索引记录，因为 KEY_TSKTASK_MONTIME2 是非簇索引，为执行该语句，MySQL 还会锁定簇索引（主键索引）。

假设“update TSK_TASK set STATUS_ID=1067,UPDATE_TIME=now () where ID in (9921180)”几乎同时执行时，本语句首先锁定簇索引 (主键)，由于需要更新 STATUS_ID 的值，所以还需要锁定 KEY_TSKTASK_MONTIME2 的某些索引记录。

这样第一条语句锁定了 KEY_TSKTASK_MONTIME2 的记录，等待主键索引，而第二条语句则锁定了主键索引记录，而等待 KEY_TSKTASK_MONTIME2 的记录，这样死锁就产生了。

我们通过拆分第一条语句解决了死锁问题：即先查出符合条件的 ID：

  1. select ID from TSK_TASK where STATUS_ID=1061 and MON_TIME < date_sub(now(), INTERVAL 30 minute)；

然后再更新状态：

  1. update TSK_TASK set STATUS_ID=1064 where ID in (….);

结束语

我们发现，死锁虽然是较早就被发现的问题，但是很多情况下我们设计的程序里还是经常发生死锁情况。我们不能只是分析如何解决死锁这类问题，还需要具体找出预防死锁的方法，这样才能从根本上解决问题。总的来说，还是需要系统架构师、程序员不断积累经验，从业务逻辑设计层面彻底消除死锁发生的可能性。