线程的死锁

死锁的理解： 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

说明： 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续，程序也不会终止，线程死亡不了，也执行不了

注意：我们使用同步时要避免死锁

演示线程的死锁问题（采用匿名类的方式）
等待同步锁时处于阻塞状态，目前同步锁都是一个

package test0;

public class ThreadDemo {
    public static void main(String[] args) {
        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();
        //创建第一个线程
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        sleep(100);//在s1阻塞的0.1秒内，下面那个线程太有可能执行了，就拿到了s2，就死锁了
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){//锁是嵌套关系
                        s1.append("b");
                        s2.append("2");
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(s1);
                        System.out.println(s2);//也就是说：如果有一个线程拿到了s1对应的锁，做完append操作之后，要拿到s2的锁才能继续做里面的事
                        //也就是说有两把锁s1和s2
                    }
                }
            }
        }.start();
        //再来一个线程，用另外一种方式，实现Runnable接口，还是写成匿名的
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    synchronized (s1){//锁是嵌套关系
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);//也就是说：如果有一个线程拿到了s2对应的锁，做完append操作之后，要拿到s1的锁才能继续做里面的事
                        //也就是说有两把锁s1和s2
                    }
                }
            }
        }).start();//相当于我们给new Thread传了一个实现Runnable类的对象，只不过是匿名的
    }
}
//上面的代码在没有用sleep之前是有可能出现死锁的，只是概率小，可以通过sleep大大增加发生死锁的概率
/*
其中一种可能的结果为              另一种可能的结果为               还有一种可能是
ab                              cd                              两个线程分别拿到了s1和s2锁
12                              34                              但由于下一把锁都在对方手里
abcd                            cdab                            所以两个都执行不了下一步
1234                            3412                            变成死锁
说明先执行上面那个                说明先执行下面那个

 */
 

死锁的演示：

package test0;

//分析：主线程要先握住a再握住b，这样方法才能结束，才能去释放a，b，分线程是先拿住b，再去拿a，又因为有sleep，所以很容易死锁
class A {
	public synchronized void foo(B b) {//同步锁为this，这里分析可知即为a
		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() {//锁为this，在这里是a

		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {//锁为this，这里为b
		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() {//这把锁是this，分析程序为b
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();//启动分线程，实现DeadLock中的run方法
		dl.init();//主线程
	}
}

解决方法
1)使用专门的算法（避开先调a再调b，先调b再调a）、原则
2)尽量减少同步资源的定义，尽量少使用同步资源，有的时候没必要使用同步就不用同步，避免效率低和死锁
3)尽量避免嵌套同步
注意：不是说看起来没出现死锁程序就没有问题，程序可能是会出现死锁的，这只是概率问题。