java死锁产生的一个简单代码

首先说下死锁产生的原因：

    不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，若无外力作用，它们都将无法推进下去，就形成了死锁。

先创建两个锁A和B，并且私有其构造器，保证外界无法通过构造器访问A和B，同时加上 public final static修饰确保A和B产生的对象的唯一性

public class LockA {
    private LockA(){}
    public final static LockA lockA  = new LockA();
}

public class LockB {
    private LockB(){}
    public final static LockB lockB  = new LockB();
}

创建一个DeadLock类实现Runnable接口

public class DeadLock implements Runnable {
    int i = 0;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        //用while(ture)表示需要循环的次数多，这样出现死锁的概率就很大，所以用死循环，确保一定会出现死锁
        while(true){
            if(i % 2 == 0){
                //先进入A同步，用LockA.lockA获得的LockA对象，由于lockA用public static final修饰所以lockA对象一定是唯一的
                synchronized (LockA.lockA) {
                    System.out.println("if.....lockA");
                    //再进入B同步，用LockB.lockB获得的LockB对象，由于lockB用public static final修饰所以lockB对象一定是唯一的
                    synchronized (LockB.lockb) {
                        System.out.println("if.....lockB");
                    }
                }
                
            }else{
                //先进入B同步，用LockB.lockB获得的LockB对象，由于lockB用public static final修饰所以lockB对象一定是唯一的
                synchronized (LockB.lockb) {
                    System.out.println("if.....lockB");
                    //再进入A同步，用LockA.lockA获得的LockA对象，由于lockA用public static final修饰所以lockA对象一定是唯一的
                    synchronized (LockA.lockA) {
                        System.out.println("if.....lockA");
                    }
                }
            }
            i++;
        }
    }
}

测试代码如下：

public class DeadLockDemo {
    public static void main(String[] args) {
        DeadLock d = new DeadLock();
        Thread t0 = new Thread(d);
        Thread t1 = new Thread(d);
        t0.start();
        t1.start();
    }
}

当线程A先获得锁A时，在想要获得锁B时，可能线程B已经获得了锁B，由于LockA和LockB是唯一的，此时锁A就无法获得锁B，同样的此时锁B也无法获得锁A，他们两就这样僵持下去，谁也不先释放，此时就发生了死锁。

测试结果：