编写一个简单的死锁

参考博客： https://www.cnblogs.com/mudao/p/5867107.html

public class Dead_Lock1 {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";

    public static void main(String[] args) {
        Thread thread1 = new Thread(new runnable1());
        Thread thread2 = new Thread(new runnable2());

        thread1.start();
        thread2.start();
    }
}

class runnable1 implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("runnable1 running.");

            while (true) {
                synchronized (Dead_Lock1.obj1) {
                    System.out.println("runnable1 lock obj1");
                    Thread.sleep(1000);
                    synchronized (Dead_Lock1.obj2) {
                        System.out.println("runnable1 lock obj2");
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class runnable2 implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("runnable2 running.");
            while (true) {
                synchronized (Dead_Lock1.obj2) {
                    System.out.println("runnable2 lock obj2");
                    Thread.sleep(1000);
                    synchronized (Dead_Lock1.obj1) {
                        System.out.println("runnable2 lock obj2");
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

obj1 和 obj2 都是属于类的字符串常量。

main函数中，运行了两个线程。

runnable1 的对象获得了 obj1 的锁。 Thread.sleep(1000)。    等待 obj2 的锁的释放 来获取 obj2 的锁。

runnable2 的对象获得了 obj2 的锁。 Thread.sleep(1000)。    等待 obj1 的锁的释放 来获取 obj1 的锁。

在两个线程开始执行之后，如上面两行所示。两个线程执行到 Thread.sleep(1000) 之后，发现要获取的锁都被对方占用了，而本身又不能释放已经持有的锁。所以双方相互等待对方锁的释放，造成死锁。