同一个java虚拟机内死锁

public class DeadLock implements Runnable{

    private int count = 100;

    public int flag = 1;

    private Object lock = new Object();


    public synchronized void cut1(){

        if(flag == 1) {

            cut2();

        }else {

            while (true) {
                if (count > 0) {
                    try {
                        //这里是为了让判断和修改打印之间的间隔加大，增加并发问题出现的概率
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + count--);
                }

            }


        }

    }


    public void cut2() {

        if(flag != 1) {

            synchronized (lock){
                cut1();
            }

        }else {

            while (true) {

                synchronized (lock) {

                    if (count > 0) {
                        try {
                            //这里是为了让判断和修改打印之间的间隔加大，增加并发问题出现的概率
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + ":" + count--);
                    }

                }
            }


        }

    }

    @Override
    public void run() {
        if(flag == 1){
            cut1();
        }else{
            cut2();
        }
    }

    public static void main(String[] args) {

        DeadLock deadLock = new DeadLock();

        //这两个线程对象的 target 都是 同一个对象 deadLock
        Thread thread1 = new Thread(deadLock);
        Thread thread2 = new Thread(deadLock);

        thread1.start();

        try {
            // 防止 thread1 执行的慢，等flag==0 的时候才开始执行
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        deadLock.flag = 0;

        thread2.start();

    }
}

public class DeadLock1 implements Runnable{

    public static Object lock1 = new Object();
    public static Object lock2 = new Object();

    private int flag = 1;

    public DeadLock1(int flag){
        this.flag = flag;
    }

    @Override
    public void run() {

        String n = Thread.currentThread().getName();

        if(flag == 1){
            synchronized (DeadLock1.lock1){
                System.out.println(n + "获取了lock1 , 等待获取lock2");
                synchronized (DeadLock1.lock2){
                    System.out.println(n + "先获取了lock1 , 又获取lock2");
                }
            }
        }else {
            synchronized (DeadLock1.lock2){
                System.out.println(n + "获取了lock2 , 等待获取lock1");
                synchronized (DeadLock1.lock1){
                    System.out.println(n + "先获取了lock2 , 又获取lock1");
                }
            }
        }

    }

    public static void main(String[] args) {

        DeadLock1 deadLock = new DeadLock1(1);
        DeadLock1 deadLock1 = new DeadLock1(2);

        //这两个线程对象的 target 都是 同一个对象 deadLock
        Thread thread1 = new Thread(deadLock);
        Thread thread2 = new Thread(deadLock1);

        thread1.start();

        thread2.start();

    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadLock2 implements Runnable {

    public static Lock lock1 = new ReentrantLock();
    public static Lock lock2 = new ReentrantLock();

    private int flag = 1;

    public DeadLock2(int flag) {
        this.flag = flag;
    }

    @Override
    public void run() {

        String n = Thread.currentThread().getName();

        if (flag == 1) {

            lock1.lock();
            System.out.println(n + "先获取了lock1 , 等待获取lock2");

            lock2.lock();
            System.out.println(n + "先获取了lock1 , 又获取lock2");

            lock2.unlock();

            lock1.unlock();

        } else {

            lock2.lock();
            System.out.println(n + "先获取了lock2 , 等待获取lock1");

            lock1.lock();
            System.out.println(n + "先获取了lock2 , 又获取lock1");

            lock1.unlock();

            lock2.unlock();

        }
    }


    public static void main(String[] args) {

        DeadLock2 deadLock = new DeadLock2(1);
        DeadLock2 deadLock1 = new DeadLock2(2);

        //这两个线程对象的 target 都是 同一个对象 deadLock
        Thread thread1 = new Thread(deadLock);
        Thread thread2 = new Thread(deadLock1);

        thread1.start();

        thread2.start();

    }
}