有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁，即线程持有锁，但是还要去争夺其它线程的锁。
    死锁可以简单理解为：“吃着碗里的，瞅着锅里的”

    t1 线程 获得 A对象 锁，接下来想获取 B对象 的锁
    t2 线程 获得 B对象 锁，接下来想获取 A对象 的锁

    例如：

    1. public class TestDeadLock {
    2.     public static void main(String[] args) {
    4.     }
    5.     public static void test1(){
    6.         Object A  = new Object();
    7.         Object B = new Object();
    8.         Thread t1 = new Thread(()->{
    9.             synchronized (A){
    10.                 System.out.println("Lock A");
    11.                 try {
    12.                     Thread.sleep(1000);
    13.                 } catch (InterruptedException e) {
    14.                     e.printStackTrace();
    15.                 }
    16.                 synchronized (B){
    17.                     System.out.println("Lock B");
    18.                     System.out.println("操作....");
    19.                 }
    20.             }
    21.         },"t1");
    23.         Thread t2 = new Thread(()->{
    24.             synchronized (B){
    25.                 System.out.println("Lock B");
    26.                 try {
    27.                     Thread.sleep(500);
    28.                 } catch (InterruptedException e) {
    29.                     e.printStackTrace();
    30.                 }
    31.                 synchronized (A){
    32.                     System.out.println("lock A");
    33.                     System.out.println("操作....");
    34.                 }
    35.             }
    36.         },"t2");
    37.         t1.start();
    38.         t2.start();
    39.     }
    40. }

    线程t1和t2并发执行，t1获得A对象的锁，t2获得B对象的锁，t1执行到synchronized(B)时由于锁被t2占有而阻塞住，t2执行到synchronize(A)时由于锁被t1占有而阻塞住，线程同时阻塞住，陷入死锁状态。