线程的死锁问题

一、死锁

• 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
• 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

二、死锁示例代码

示例一

通过Thread.sleep(100)模拟线程发生死锁，线程1拿到了s1锁，然后睡眠，等待再拿s2锁。而线程2拿到了s2锁，然后睡眠，等待再拿s1锁。这样两个线程互相等待可能就发生死锁。

public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();


        new Thread(){
            @Override
            public void run() {

                synchronized (s1){      //先拿s1锁

                    s1.append("a");
                    s2.append("1");

                    synchronized (s2){  //再拿s2锁

                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();


        //实现Runnable接口的匿名线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){         //先拿s2锁

                    s1.append("c");
                    s2.append("3");

                    synchronized (s1){      //再拿s1锁

                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

示例二

DeadLock类中分别创建A类和B类对象，DeadLock类实现Runnable接口，重写run()方法
main()方法中启了一个副线程dl，副线程dl执行run()方法，主线程执行dl.init()。

主线程：
init() --> 调用a.foo(b)[同步方法需要拿到锁：a] --> 输出打印 --> sleep(200) -->输出打印 --> 调用b.last()[同步方法需要拿到锁：b] --> 输出打印

副线程：
start() --> run() --> 调用b.bar(a)[同步方法需要拿到锁：b] --> 输出打印 --> sleep(200) -->输出打印 --> 调用a.last()[同步方法需要拿到锁：a] --> 输出打印

主线程先拿a锁，再拿b锁，而副线程先拿b锁，再拿a锁，由于sleep睡眠的问题，就有可能使得两个线程发送死锁。

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方法内部");
	}
}

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();
		dl.init();
	}
}