关于线程死锁

死锁可以这样认为：多个线程同时被阻塞，它们中的一或者全部都在等待某个资源被释放（例如有a,b两个线程，a等待b让出了某个资源才可以执行；而b同样等待a让出了某个资源才可以继续，ab都在等待对方就是线程同时阻塞，结局就是死锁） 。

产生死锁的四个必要条件：

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

例子：

package com.lwh.test;

public class DeadLock implements Runnable {

    A a = new A();
    B b = new B();

    public void init() {
        Thread.currentThread().setName("主线程");
        System.out.println("进入主线程");
        a.foo(b);
    }

    public void run() {
        Thread.currentThread().setName("副线程");
        System.out.println("进入副线程");
        b.bar(a);
    }

    public static void main(String[] args) {
        DeadLock dl = new DeadLock();//主线程
        new Thread(dl).start();//副线程
        dl.init();//主线程
        
    }
}

class A {

    public synchronized void foo(B b) {
        System.out.println(Thread.currentThread().getName() + " 进入A的foo");
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 试图调用B的last");
        b.last();
    }
    
    public synchronized void last() {
        System.out.println("A的last()");
    }
}

class B {

    public synchronized void bar(A a) {
        System.out.println(Thread.currentThread().getName() + " 进入B的bar");
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 试图调用A的last");
        a.last();
    }

    public synchronized void last() {
        System.out.println("B的last()");
    }
}

分析：

下面是运行结果：

进入主线程
进入副线程
主线程 进入A的foo
副线程 进入B的bar
副线程 试图调用A的last
主线程 试图调用B的last

我们看到，正常情况下，最后还应该打印出“A的last()”和"B的last()",但是因为线程死锁的原因，所以程序一直在等待执行，没能正常的执行下去。

在上面的代码里面，为什么会出现死锁这种情况呢？简单分析一下。

首先虽然副线程的start()是在主线程的init()之前，但是因为多线程开启也需要一段时间，所以我们可以看到，是主线程的init()方法执行在前，然后在init()里面调用了a.foo()。A类和B类中的方法都是同步方法，因此，A的对象和B的对象都是同步锁。在进入A的foo()之前，线程会对A加锁，然后线程睡眠200ms，这时候副线程调用B的bar()，同样的会对B加锁，然后睡眠200ms。这时候，主线程唤醒，试图调用B的bar方法，因为是同步方法，所以需要对B加锁，但是这时候B已经被副线程锁住了，所以主线程就一直处于阻塞状态。当副线程唤醒的时候，试图调用A的同步方法，同样需要对A加锁，但是这时候主线程持有A的锁，并处于阻塞状态，所以副线程也不能向下执行，大家都在等着对方释放锁，因此出现了我们上面说的死锁的情况。

如果我们把A和B的last()的synchronized去掉，那么程序在调用last()之前就不需要对对象进行加锁，也就不会出现死锁的情况。