java—线程的死锁问题

public class ThreadTest {

    public static void main(String[] args) {
        //s1 s2作为同步监视器（锁）
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();


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

                synchronized (s1){

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

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }


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

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


                }

            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){

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

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

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

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


                }



            }
        }).start();


    }


}

• 注释
• s1 s2作为两个同步监视器（锁）
• 在main方法中创建两个Thread类的子类，并重写了其run方法。然后再用这两个子类调用start（）方法，开启两个线程。
• 子类中的同步代码块进行了嵌套
• 子类1拿到锁s1时就可以执行最外层的同步代码块的代码，但是要想执行完最外层的同步代码块的代码，需要再拿到锁s2才可以。
• 子类2拿到锁s2时就可以执行最外层的同步代码块的代码，但是要想执行完最外层的同步代码块的代码，需要再拿到锁s1才可以。
• 如果当子类1拿到s1，子类二拿到s2时，都开始执行最外层的同步代码块的代码。
• 但是子类2因为拿不到s1，所以就不会丢掉s2，但是子类1因为拿不到s2，所以就不会丢掉s1，出现了死锁的问题

另一个死锁的例子

package com.atguigu.java1;

//死锁的演示
//主线程和副线程之间产生了死锁

class A {
	public synchronized void foo(B b) { //因为是非static，所以同步监视器为（this）：A类的对象：a
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①

		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last(){}
}

class B {
	public synchronized void bar(A a) {//同步监视器为：B的对象：b
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②

		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void 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);
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
	}

	public static void main(String[] args) {

		DeadLock dl = new DeadLock();

		//开启了一个副线程，执行的是DeadLock类的run（）方法
		//run方法中需要调用b.bar（）方法，是一个同步方法，要想执行需要拿到锁b
		//但是b.bar（）方法中要调用a.last（）方法，是一个同步方法，要想执行需要拿到锁a
		new Thread(dl).start();

		//这个这是在主线程中执行的
		//d1.init（）方法中需要调用a.foo（）方法，是一个同步方法，要想执行需要拿到锁a
		//但是a.foo（）方法中要调用b.last（）方法，是一个同步方法，要想执行需要拿到锁b
		dl.init();
	}
}