毕老师基础视频中的一个例子:
一直想,总觉得不可能有和谐的情况啊;就算有一两次和谐也应该在最开始时候.t1.t2开始运行时的先后时间差造成的
但是视频中,老师说这段代码有可能和谐运行 :dizzy:不明白
class Test implements Runnable
{
        private boolean flag = true;

        Test (boolean flag)//带标记的构造函数,方便传标记给线程,以便控制两个线程运行于两个不一样的同步块
        {
                this.flag = flag;
        }

        public void run()
        {
        while(true)    //然线程处于不断循环状态,好看结果
                {
                if(flag)   //线程1运行在这里面
                        {
                        synchronized(Suo.suo1)
                                {
                                System.out.println("线程1++++++++++外层");
                                synchronized(Suo.suo2)
                                        {
                                                System.out.println("线程1==========内层");
                                        }
                                }
                                
                        }
               
                else   //线程2运行在这里面
                        {
                        synchronized(Suo.suo2)
                                {
                                System.out.println("线程2:外层");
                                synchronized(Suo.suo1)
                                        {
                                                
                                                System.out.println("线程2内层");
                                        }
                                }
                        }
                }
        }

}

class Suo//建立锁的类,只是方便试验
{
        static Object suo1 = new Object();//锁1
        static Object suo2 = new Object();//锁2
}

class DeadLockTest
{        
        public static void main(String[] args)
        {
        //建立两个线程并运行
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
        }
}

毕老师基础视频中的一个例子:
一直想,总觉得不可能有和谐的情况啊;就算有一两次和谐也应该在最开始时候.t1.t2开始运行时的先后时间差造成的
但是视频中,老师说这段代码有可能和谐运行 :dizzy:不明白
class Test implements Runnable
{
        private boolean flag = true;

        Test (boolean flag)//带标记的构造函数,方便传标记给线程,以便控制两个线程运行于两个不一样的同步块
        {
                this.flag = flag;
        }

        public void run()
        {
        while(true)    //然线程处于不断循环状态,好看结果
                {
                if(flag)   //线程1运行在这里面
                        {
                        synchronized(Suo.suo1)
                                {
                                System.out.println("线程1++++++++++外层");
                                synchronized(Suo.suo2)
                                        {
                                                System.out.println("线程1==========内层");
                                        }
                                }
                                
                        }
               
                else   //线程2运行在这里面
                        {
                        synchronized(Suo.suo2)
                                {
                                System.out.println("线程2:外层");
                                synchronized(Suo.suo1)
                                        {
                                                
                                                System.out.println("线程2内层");
                                        }
                                }
                        }
                }
        }

}

class Suo//建立锁的类,只是方便试验
{
        static Object suo1 = new Object();//锁1
        static Object suo2 = new Object();//锁2
}

class DeadLockTest
{        
        public static void main(String[] args)
        {
        //建立两个线程并运行
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
        }
}