如果让你写一个死锁的例子，怎么写呢？其实死锁的原理很简单，就是某个线程一直占有共享资源不释放，导致其他线程无法获取到资源，而一直无法执行

1.实例代码

最简单的一个例子：

class Solution {
    static Object lock1 = new Object();
    static Object lock2 = new Object();

    public static void main(String[] args) {

        new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (lock1) {
                    System.out.println("thread1 get lock1");

                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                    }

                    synchronized (lock2) {
                        System.out.println("thread1 get lock2");
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (lock2) {
                    System.out.println("thread2 get locked2");

                    
                    synchronized (lock1) {
                        System.out.println("thread2 get locked1");
                    }
                }
            }
        }).start();
    }
}

线程A和线程B，分别去首先申请了自己的锁（lock1、lock2），线程A在申请锁之后，做了一些操作，然后去申请lock2，但是这时我们发现一个有趣的现象，线程B开始运行之后，申请到lock2之后，也在等待lock1，此时产生了一种“互锁的尴尬境地”，即：线程A和线程B，都在等待对方的锁，可是本身自己锁又无法释放。
其实上面的例子很简单，但是我们也知道正常编码中，估计大家也不会特意写这样的代码--在一个线程内部申请多个资源的锁，但是我们也知道开发一个系统、APP往往是一个团队在负责，多人协作开发一个功能是再正常不过的事情，这时的系统代码可能绕了N层、N个接口、N个调用，所以小概率出现这种现象的可能还是有的。

2.从实例看透本质

从实例中，我们理解死锁的四个条件，就很好理解了。

1）互斥条件

指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

2）请求和保持条件

指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

3）不剥夺条件

指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。

4）环路等待条件

指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

那相对应，避免死锁出现的策略就很简单了，只要破坏死锁的四个条件中的额任何一个就可以了。

如何破坏：

互斥条件：copy资源的副本？
请求和保持条件：一个线程一次处理，只能请求一个锁？
不剥夺条件：为了防止线程不主动释放资源，设置一个超时时间？
环路等待条件：一个线程，处理过程，不可以请求多个锁？