/**
* 线程死锁
* @author 签约test
*
*/
public class TestDeadLock {
/**
* I want to say ,in there the lock1 and the lock2 isn’t
* common lock ,But in there we must notice that the String lock1=””
* and String lock2 = “” is a common lock ,because in the Constant pool
* they are a common string ,so we must realize that if the String value
* is same when we don’t use the keywords “new”,they will be a same final
* field.
*/
private static String lock1 = “”;
private static String lock2 = “1”;

private static class Thread1 extends Thread{
    @Override
    public void run() {
        synchronized(lock1){
            System.out.println("OK,the Thread1 have got the lock \"lock1\" " +
                    "and wait for sleep ,in a moment ,get the lock2 and " +
                    "finish all the work!!!");
            try {
                //Onhn, he is sleeping ,Yeah I know
                sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //now ,I need the lock "lock2"
            synchronized(lock2){
                System.out.println("OK , I am the Thread1 and I have got " +
                        "the \"lock2\" and I will finish all at once");
            }
        }
    }

}
private static class Thread2 extends Thread{
    @Override
    public void run() {
        synchronized(lock2){
            System.out.println("OK,I am the Thread 2 and 1 have got the lock \"lock2\"" +
                    "because I would like to make a deadLock ,Maybe you think I am so" +
                    "foolish ,but I want tell I am having a test ,yeah only  A test" +
                    "in the test I have got the lock \"lock2\"and I know that the Thrad1" +
                    "have got the lock \"lock1\" and I will go in a deadLock" +
                    "Yeah interesting!!!" +
                    "OK let's go");

            synchronized(lock1){
                System.out.println("OK , I am the Thread2 and I know that" +
                        "the demo willn't run because I ....yeah I know " +
                        "A deadLock ,interesting!!!");
            }
        }
    }

}

/**
 * OK ,have a try
 * @param args
 */
public static void main(String[] args) {
    Thread1 th1 = new Thread1();
    Thread2 th2 = new Thread2();
    /**
     * Yeah ,I deem that i should write a note to tell you what happened
     * but I think i have give the note the console ,yeah I have give it 
     * to console ,so I think new i needn't write note .enhn, I tell you
     * all of this 
     */
    //now we must start them ,and the JVM will get them run ,I konw
    //I won't interrupt
    th1.start();
    th2.start();

}

}

public class DeadLocak {

    private final Object left = new Object();
    private final Object right = new Object();

    public void leftRight() throws Exception {
        synchronized (left) {
            Thread.sleep(2000);
            synchronized (right) {
                System.out.println("leftRight end!");
            }
        }
    }

    public void rightLeft() throws Exception {
        synchronized (right) {
            Thread.sleep(2000);
            synchronized (left) {
                System.out.println("rightLeft end!");
            }
        }
    }

    public static void main(String[] args) {
        final DeadLocak deadLocak = new DeadLocak();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    deadLocak.leftRight();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    deadLocak.rightLeft();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

利用jstack -pid 号查看发现

模拟2种出现死锁的方式
（1）锁资源互斥（锁资源被占用）
（2）读写锁互斥性

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 死锁
 *
 * @Ahthor luohq
 * @Date 2020-07-23
 */
public class Deadlock {


    public static void main(String[] args) {
        deadLock1();
        //deadLock2();
        //wrLockDowngrade();
    }


    /**
     * 死锁 - 资源互斥
     */
    public static void deadLock1() {
        Object lock1 = new Object();
        Object lock2 = new Object();

        new Thread(() -> {
            synchronized (lock1) {
                System.out.println("thread1 get lock1");
                //睡眠5秒（模拟进行耗时的操作，同时以使thread2优先获取lock2）
                sleep(5000L);
                synchronized (lock2) {
                    System.out.println("thread1 get lock2");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (lock2) {
                System.out.println("thread2 get lock2");
                sleep(5000L);
                synchronized (lock1) {
                    System.out.println("thread2 get lock1");
                }
            }
        }).start();
    }

    /**
     * 读写锁死锁 - 获取写锁后无法再获取读锁
     *
     * 1.读锁支持共享（可同时获取读锁、获取读锁后无法再获取写锁）
     * 2.写锁排他锁（获取写锁后无法再获取写锁、读锁）
     * 3.支持锁降级（写锁 -> 读锁）
     * 4.不支持锁升级（读锁 -> 写锁）
     */
    public static void deadLock2() {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock rLock = rwLock.readLock();
        ReentrantReadWriteLock.WriteLock wLock = rwLock.writeLock();

        new Thread(() -> {
            rLock.lock();
            System.out.println("thread1 get rLock");
            wLock.lock();
            System.out.println("thread1 get wLock");
            rLock.unlock();
            wLock.unlock();
        }).start();

    }

    /**
     * 锁降级 - 写锁降级为读锁
     * 同时ReentrantReadWriteLock支持线程内重入（若不支持重入则获取锁后，在同线程内再次获取锁则出现死锁）
     */
    public static void wrLockDowngrade() {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock rLock = rwLock.readLock();
        ReentrantReadWriteLock.WriteLock wLock = rwLock.writeLock();

        /** 【锁降级】可以正常执行：同一个线程中获取写锁 -> 获取读锁 -> 释放写锁 -> 释放读锁 */
        new Thread(() -> {
            wLock.lock();
            System.out.println("thread2 get wLock");
            rLock.lock();
            System.out.println("thread2 get rLock");
            wLock.unlock();
            rLock.unlock();
        }).start();

    }

    public static void sleep(Long mills) {
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}