为什么死锁程序写出来，咋程序结果不容易死锁呢？
package day04;

class Test1 implements Runnable {
          Object locka = new Object();
          Object lockb = new Object();
        private boolean flag = true;

        Test1(boolean flag) {
                this.flag = flag;
        }

        public void run() {
                if (flag) {
                        while (true) {
                                synchronized (locka) {
                                        try {
                                                Thread.sleep(100);
                                        } catch (InterruptedException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        System.out.println("if lock");
                                        synchronized (lockb) {
                                                System.out.println("if lock");
                                        }

                                }
                        }
                } else {
                        while (true) {
                                synchronized (lockb) {
                                        try {
                                                Thread.sleep(100);
                                        } catch (InterruptedException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        System.out.println("else lock");
                                        synchronized (locka) {
                                                System.out.println("else lock");
                                        }

                                }
                        }
                }
        }
}

public class DeadLockTest {

        public static void main(String[] args) {

                Thread t1 = new Thread(new Test1(true));
                Thread t2 = new Thread(new Test1(false));
               
                t1.start();
               
               
                t2.start();

        }

}
如果把Object locka = new Object();
          Object lockb = new Object();
改成
static Object locka = new Object();
static Object lockb = new Object();
立马就死锁了，为啥？
难道静态的东西和在内存中new一个对象有什么区别？

难道Object locka = new Object();
          Object lockb = new Object();

这个作为锁就不死锁了吗

静态的对象只会被建立一次
你new Test1的时候
如果先前没有new过Test1
也就是这是第一次new Test1
那么静态对象locka，lockb会被建立一次
但你再次new Test1的时候
内存中已经存在了静态的对象locka，lockb
不会再去新建

你看一下关系图就知道了，不加静态，一个线程两个锁，怎么可能会产生死锁。

  Thread t1 = new Thread(new Test1(true));
  Thread t2 = new Thread(new Test1(false));

new了两次Test1，如果不是静态的话锁是不一样的
synchronized (locka) 也就是synchronized (this.locka)

你应该是参照毕老师的视频写的程序吧，我昨天也看到了这里，你想一个事，他这集视频说了一句什么话，可能和谐，什么是和谐。。。回复完毕，楼主可以自己去看视频，多听几次

如果资源类中：
static Object locka = new Object();
static Object lockb = new Object();

那么你资源类中会共享这个两个对象，并且当你新建另外一个资源类的对象，不会进行重新创建两个已经存在的静态成员；
所以你不管新建多少资源对象，他们的锁还是唯一的；所以同步的前提是锁的唯一性

new两个Test1不就是生成了两个任务对象吗？那这两个线程操作的不就不是同一份数据了吗？不是应该new一个Test1，然后分别传给Thread吗？

如果资源类中：
static Object locka = new Object();
static Object lockb = new Object();

那么你资源类中会共享这个两个对象，并且当你新建另外一个资源类的对象，不会进行重新创建两个已经存在的静态成员；
所以你不管新建多少资源对象，他们的锁还是唯一的；所以同步的前提是锁的唯一性

撸主是想写个死锁的例子

Thread t1 = new Thread(new Test1(true));
Thread t2 = new Thread(new Test1(false));
其实我觉得是你是这句话没搞懂，  new Test1（）； 的含义
产生 t1的时候，类Test加载，产生了两个锁locka，lockb，
产生t2的时候，这个事关键点，
static Object locka = new Object();
static Object lockb = new Object();
如果是静态的话，静态只加载一次，就不会产生锁了，t2和t1共用两个锁，可以锁住
如果 非静态
Object locka = new Object();
Object lockb = new Object();
new Test（false）会再创立两个锁， 给t2
那么t1 t2 各自有两把锁【一共四把】，名字还都一样，当t1执行的时候，怎么可能锁住t2呢？是不是了？