死锁就是多个线程发生了互相等待的情况。
    如下代码，t1获取了lock1，并希望获取lock2.
    t2已经获取了lock2，并希望获取lock1.
    在这种情况下，两边都在等待获取锁，这就导致了两边都不会结束，也不会释放锁。

    2. public class DeadLock {
    3.     public static void main(String[] args) {
    5.         Object lock1 = new Object();
    6.         Object lock2 = new Object();
    9.         Thread t1 = new Thread(new Runnable() {
    10.             @Override
    11.             public void run() {
    12.                 synchronized (lock1) {
    13.                     try {
    14.                         Thread.sleep(1000);
    15.                     } catch (Exception e) {
    16.                     }
    18.                     synchronized (lock2) {
    19.                     }
    20.                 }
    21.             }
    22.         }, "deadLock - 1");
    24.         t1.start();
    25.         ExecutorService executorService = Executors.newFixedThreadPool(200);
    26.         for (int i = 0; i < 200; i++) {
    27.             executorService.submit(new Runnable() {
    29.                 @Override
    30.                 public void run() {
    31.                     synchronized (lock2) {
    32.                         try {
    33.                             Thread.sleep(1000);
    34.                         } catch (Exception e) {
    35.                         }
    37.                         synchronized (lock1) {
    38.                         }
    39.                     }
    40.                 }
    41.             });
    42.         }
    45.     }
    46. }

    当然在实际中，我们是不会写出这种代码的。
    但是有可能产生不同服务之间的死锁，两个服务互相等待的情况。

    那么避免死锁产生的几个常用方法：

    • 避免一个线程同时获取多个锁。
    • 避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
    • 尝试使用定时锁，使用lock.tryLock（timeout）来替代使用内部锁机制。
    • 对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

    以上摘自《Java并发编程的艺术》。