06 线程死锁

问题

什么是线程死锁

答案

举一个很形象的例子，有两扇门D1、D2，两把锁 S1、S2，每把锁有一个钥匙 K1、K2，按如下方式操作：把K2放到D1，用S1锁上D1；把K1放到D2，用S2锁上D2。这时候，要进D1，就得用K1打开S1，但是S1在D2，要打开D2，但是S2在D1，两边都进行不下去，处于阻塞状态。这时候，除非有外力打破这种状态，要不然会一直持续下去。这就是死锁。
操作系统中对死锁的定义是：一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源。
形成死锁有四个条件：
(1)互斥使用：一个资源每次只能给一个进程使用
(2)占有且等待：进程在申请新的资源的同时保持对原有资源的占有
(3)不可抢占：资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放
(4)循环等待：存在一个进程等待队列 {P1 , P2 , … , Pn}，其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路。
当死锁产生的时候一定会有这四个条件，有一个条件不成立都不会造成死锁。因此，处理和预防死锁也是规避或者破坏这四个条件中的某一个或者某几个。在java中，下面的代码就会造成死锁：

    public static void main(String[] args) {
        final Object lock1 = new Object();
        final Object lock2 = new Object();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName() + "锁住/获得lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {
                        // 执行不到这里
                        System.out.println("1秒钟后，" + Thread.currentThread().getName()
                                + "锁住/获得lock2");
                    }
                }
            }
        }, "线程1");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock2) {
                    System.out.println(Thread.currentThread().getName() + "锁住/获得lock2");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock1) {
                        // 执行不到这里
                        System.out.println("1秒钟后，" + Thread.currentThread().getName()
                                + "锁住/获得lock1");
                    }
                }
            }
        }, "线程2");

        t1.start();
        t2.start();
    }

上面的程序中，互斥使用、占有且等待、不可抢占均是synchronized 特性无法破坏，只有循环等待可以破坏，假设两个线程锁资源的顺序如果都是lock1，lock2，则就可以避免死锁，代码如下：

    public static void main(String[] args) {
        final Object lock1 = new Object();
        final Object lock2 = new Object();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName() + "锁住/获得lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {
                        // 执行不到这里
                        System.out.println("1秒钟后，" + Thread.currentThread().getName()
                                + "锁住/获得lock2");
                    }
                }
            }
        }, "线程1");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock1) {//这是第一个修改的地方法lock2变成lock1
                    System.out.println(Thread.currentThread().getName() + "锁住/获得lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {//这是第一个修改的地方法lock1变成lock2
                        // 执行不到这里
                        System.out.println("1秒钟后，" + Thread.currentThread().getName()
                                + "锁住/获得lock2");
                    }
                }
            }
        }, "线程2");

        t1.start();
        t2.start();
    }