public class TestDeadLock implements Runnable {
        public int flag = 1;                                        //作用是什么
        static Object o1 = new Object();                  //作用是什么

        static Object o2 = new Object();                  //作用是什么

                  
        public void run() {
    System.out.println("flag=" + flag);
   
   
   
                if(flag == 1) {                        
                        synchronized(o1) {
                                try {
                                        Thread.sleep(500);
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                                synchronized(o2) {
                                        System.out.println("1");        
                                }
                        }
                }
               
               
                if(flag == 0) {
                        synchronized(o2) {
                                try {
                                        Thread.sleep(500);
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                                synchronized(o1) {
                                        System.out.println("0");
                                }
                        }
                }
        }        
        
        
        public static void main(String[] args) {
                TestDeadLock td1 = new TestDeadLock();
                TestDeadLock td2 = new TestDeadLock();
                td1.flag = 1;
                td2.flag = 0;
                Thread t1 = new Thread(td1);
                Thread t2 = new Thread(td2);
                t1.start();
                t2.start();
               
        }
}
public int flag = 1;   这个是作为静态常量给main方法的flag赋值？  那为什么赋值为1？

public class TestDeadLock implements Runnable {
        public int flag = 1;                                 //1、这是定义一个标记，之后的if语句要用到。   
   static Object o1 = new Object();              //2、这是创建一个object对象，毕老师说的上帝。      
   static Object o2 = new Object();             //3、这也是个object对象。

1、flag是定义的一个标记，if（flag==1）则执行这个if中的语句，if（flag==0）则执行此个if中的语句。也可以定义一个布尔类型的变量，进行选择性的执行，同样的效果。
2、之所以要创建2个对象，是为了之后的synchronized同步代码块中需要任意对象，但同步的前提是，要多个线程必须用同一个锁，所以o1跟o2分别是2个synchronized的对象，其实这个死锁程序就是2个同步的嵌套。
                  

        public int flag = 1;                                     //作用是什么-->
                                                                         作用是定义个标记值，来判断而进入不同的同步代码块中去去执行。
     static Object o1 = new Object();                  //作用是什么
      这个的作用是创建一个上帝对象，这就是上帝对象可以作为同步代码块的对象。这是为了保证对象的唯一性。
      也可以是别的什么对象，这个就方便，不用再去创建一个类。
     static Object o2 = new Object();                  //作用是什么
      作用和上边是一样。


     public int flag = 1; 这个是作为静态常量给main方法的flag赋值？ 那为什么赋值为1？
     就是在main方法中进行给flag进行赋值，这样就在不同的线程去拿到不同锁，
     赋值为1，就相当于是true  赋值为0，就相当于是false。
    其实这就是和那个boolean值是一个原理。

public class TestDeadLock implements Runnable {
        public int flag = 1;                                        //作用是什么
//解答：定义的标志位，可以根据这条信息，执行Run（）方法中的信息，见后面解释
        static Object o1 = new Object();                  //作用是什么
//解答：定义的静态内成员变量，类的属性，可以根据设置同步代码块限制条件

        static Object o2 = new Object();                  //作用是什么
//解答，同上条

                  
        public void run() {
    System.out.println("flag=" + flag);
   
   
   
                if(flag == 1) {                        
                        synchronized(o1) {
                                try {
                                        Thread.sleep(500);
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                                synchronized(o2) {
                                        System.out.println("1");        
                                }
                        }
                }
               
               
                if(flag == 0) {
                        synchronized(o2) {
                                try {
                                        Thread.sleep(500);
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                                synchronized(o1) {
                                        System.out.println("0");
                                }
                        }
                }
        }        
        
        
        public static void main(String[] args) {
                TestDeadLock td1 = new TestDeadLock();
                TestDeadLock td2 = new TestDeadLock();
                td1.flag = 1;//这里定义flag=1;执行相应代码
                td2.flag = 0;//同上
//解释：这里flag标志位信息，同步代码块没有任何意义，flag已经做出了选择
                Thread t1 = new Thread(td1);
                Thread t2 = new Thread(td2);
                t1.start();
                t2.start();
               
        }
}
public int flag = 1;   这个是作为静态常量给main方法的flag赋值？  那为什么赋值为1？
//解答：这里的赋值是为了满足后面Run中的筛选条件，flag只要是整数就行，不一定是1，这里的重点在于run中的flag == 0、flag == 1结果的true或false