class MyLock

{

    public static Object myLockA = new Object();

    public static Object myLockB = new Object();

}

class DieLock implements Runnable

{

    private boolean flag = false;

    public void run()

    {

        if(flag)

        {

            synchronized(MyLock.myLockA)

            {

                sop("if lockA");

                synchronized(MyLock.myLockB)

                {

                    sop("if lockB")

                    

                }

            }

        }

        else

        {

            synchronized(MyLock.myLockB)

            {

                sop("if lockB");

                synchronized(MyLock.myLockA)

                {

                    sop("if lockA")

                }

            }

        }

    }

}

同学们这是看的一个死锁问题，但是他们之间怎么形成死锁的。求讲解一下

有两个锁，在A锁中，使用B锁。在B锁中使用A锁，互相等待，就会造成死锁问题

如果有两个线程，线程1和线程2，线程1进入到
if(flag)
        {
            synchronized(MyLock.myLockA)
            {
                sop("if lockA");
                synchronized(MyLock.myLockB)
                {
                    sop("if lockB")
                    
                }
            }
        }
这段代码中的sop("if lockA");这里，这时候线程A拥有A锁，然后被剥夺了执行权，执行权交给了线程2
线程2开始执行，执行到
else
        {
            synchronized(MyLock.myLockB)
            {
                sop("if lockB");
                synchronized(MyLock.myLockA)
                {
                    sop("if lockA")
                }
            }
        }
这段代码中的  sop("if lockB");，这时候线程2拥有B锁，现在这个时候线程1需要B锁才能执行下去，但是B锁在线程2手里，线程2需要A锁才能继续执行，但是A锁在线程1的手里，他们就会无限的等待下去，形成死锁

如果有两个线程，线程1和线程2，线程1进入到
if(flag)
        {
            synchronized(MyLock.myLockA)
            {
                sop("if lockA");
                synchronized(MyLock.myLockB)
                {
                    sop("if lockB")
                    
                }
            }
        }
这段代码中的sop("if lockA");这里，这时候线程A拥有A锁，然后被剥夺了执行权，执行权交给了线程2
线程2开始执行，执行到
else
        {
            synchronized(MyLock.myLockB)
            {
                sop("if lockB");
                synchronized(MyLock.myLockA)
                {
                    sop("if lockA")
                }
            }
        }
这段代码中的  sop("if lockB");，这时候线程2拥有B锁，现在这个时候线程1需要B锁才能执行下去，但是B锁在线程2手里，线程2需要A锁才能继续执行，但是A锁在线程1的手里，他们就会无限的等待下去，形成死锁

当线程进来的时候走的是else  使用了b锁  然后输出if lockB  继续往下走 进入a锁 输出if lockA   同时另一个线程从a锁进 输出if lockA 继续往下走进入b锁  输出if lockB   这个时候  一个线程要用a锁  一个线程要用b锁   这两个锁同时为锁定状态  所以无法再进入 两个互相等待 导致成了死锁

class MyLock

{

    public static Object myLockA = new Object();//定义两个线程

    public static Object myLockB = new Object();

}

class DieLock implements Runnable

{

    private boolean flag = false;

    public void run()

    {

        if(flag)//线程1进来了

        {

            synchronized(MyLock.myLockA)//线程1拿到A锁，but此时执行权被系统给了线程2，此时线程1拿着A锁等线程2那哥们上来呢

            {

                sop("if lockA");

                synchronized(MyLock.myLockB)//（最后看这里）线程1需要找到B锁才能继续执行，B锁在线程2那哥们那，怎么办呢？耗着吧..............

                {

                    sop("if lockB")

                    

                }

            }

        }

        else

        {

            synchronized(MyLock.myLockB)//线程2拿到执行权，很得意的进来了哦，它拿到了B锁往下走

            {

                sop("if lockB");

                synchronized(MyLock.myLockA)// 线程2找A锁，butA锁呢？A锁在线程1那呢，怎么办？耗着吧.........

                {

                    sop("if lockA")

                }

            }

        }

    }

}

感觉像警察跟土匪拿着枪对峙，谁也不愿意先放下手里的枪，但是谁也不开枪，咋弄？耗着呗..........死锁