1. public class ThreadDieSock implements Runnable {
   
2.     private int flag = 1;
   
3.     private Object obj1 = new Object(), obj2 = new Object();
   
4. 
   
5.     public void run() {
   
6.         System.out.println("flag=" + flag);
   
7.         if (flag == 1) {
   
8.             synchronized (obj1) {
   
9.                 System.out.println("我已经锁定obj1，休息0.5秒后锁定obj2去！");
   
10.                 try {
    
11.                     Thread.sleep(500);
    
12.                 } catch (InterruptedException e) {
    
13.                     e.printStackTrace();
    
14.                 }
    
15.                 synchronized (obj2) {
    
16.                     System.out.println("1");
    
17.                 }
    
18.             }
    
19.         }
    
20.         if (flag == 0) {
    
21.             synchronized (obj2) {
    
22.                 System.out.println("我已经锁定obj2，休息0.5秒后锁定obj1去！");
    
23.                 try {
    
24.                     Thread.sleep(500);
    
25.                 } catch (InterruptedException e) {
    
26.                     e.printStackTrace();
    
27.                 }
    
28.                 synchronized (obj1) {
    
29.                     System.out.println("0");
    
30.                 }
    
31.             }
    
32.         }
    
33.     }
    
34. 
    
35.     public static void main(String[] args) {
    
36.         ThreadDieSock run01 = new ThreadDieSock();
    
37.         ThreadDieSock run02 = new ThreadDieSock();
    
38.         run01.flag = 1;
    
39.         run02.flag = 0;
    
40.         Thread thread01 = new Thread(run01);
    
41.         Thread thread02 = new Thread(run02);
    
42.         System.out.println("线程开始喽！");
    
43.         thread01.start();
    
44.         thread02.start();
    
45.     }
    
46. }

复制代码

运行结果：
线程开始喽！
flag=0
flag=1
我已经锁定obj2，休息0.5秒后锁定obj1去！
我已经锁定obj1，休息0.5秒后锁定obj2去！
0
1

我的问题是，0 与 1 不是应该不会被打印的吗？有点懵了

1. 兄弟，你这里run01和run02是两个独立的对象，分别在各自的线程中运行,也就是各自只有一个线程在运行；
2. 这样开启多线程：Thread thread01 = new Thread(run01);
                                     Thread thread02 = new Thread(run01);
                                     thread01.start();
                                     thread02.start();

楼上说的对，你要用两个线程去操作同一个对象才会产生死锁。下面是我修改代码，一个是object 锁，一个是this锁，其实你没必要
创建两个对象作为锁，程序没有优化，楼主看看。

public class ThreadDieSock implements Runnable {
    private int flag=1;
    private Object obj = new Object();

    public void run() {
        System.out.println("flag=" + flag);
        if (flag==1) {
            synchronized (this) {
                System.out.println("我已经锁定obj1，休息0.5秒后锁定obj2去！");
                                this.flag=0;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj) {
                    System.out.println("1");
                }
            }
        }
        if (flag==0) {
            synchronized (obj) {
                System.out.println("我已经锁定obj2，休息0.5秒后锁定obj1去！");
                                this.flag=1;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (this) {
                    System.out.println("0");
                }
            }
        }
    }

    public static void main(String[] args) {
        ThreadDieSock run01 = new ThreadDieSock();
        Thread thread01 = new Thread(run01);
        Thread thread02 = new Thread(run01);
        System.out.println("线程开始喽！");
        thread01.start();
        thread02.start();
    }
}