Java 死锁

死锁

两个或两个以上的线程持有不同系统资源的锁，线程彼此都等待获取对方的锁来完成自己的任务，但是没有让出自己持有的锁，线程就会无休止等待下去

必要条件

• 互斥条件：进程中在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。
• 不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。
• 请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。
• 循环等待条件：存在一种进程资源的循环等待链(比如 demo 中的 while 循环)，链中每一个进程已获得的资源同时被链中下一个进程所请求

实现一个死锁

    @Test
    public void testLock() {
        List<Integer> l = new ArrayList<>();
        List<Integer> ll = new ArrayList<>();

        ExecutorService taskExecutor = Executors.newCachedThreadPool();
        final CountDownLatch latch = new CountDownLatch(1);

        Runnable run = () -> {
            try {
                System.out.println("线程A 开始执行");
                for(int i = 0; i< 10; i++) {
                    System.out.println("线程A 尝试锁住 list-1");
                    synchronized (ll) {
                        System.out.println("线程A 成功锁住 list-1");
                        ll.add(i);
                        System.out.println("线程A 成功添加元素进 list-1");
                        TimeUnit.SECONDS.sleep(3);
                        System.out.println("线程A 尝试锁住 list-2");
                        synchronized (l) {
                            System.out.println("线程A 成功锁住 list-2");
                            l.add(i);
                            System.out.println("线程A 成功添加元素进 list-2");
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            latch.countDown();
        };
        taskExecutor.execute(run);

        Runnable run2 = () -> {
            try {
                System.out.println("线程B 开始执行");
                for(int i = 0; i< 10; i++) {
                    System.out.println("线程B 尝试锁住 list-2");
                    synchronized (l) {
                        System.out.println("线程B 成功锁住 list-2");
                        l.add(i);
                        System.out.println("线程B 成功添加元素进 list-2");
                        TimeUnit.SECONDS.sleep(3);
                        System.out.println("线程B 尝试锁住 list-1");
                        synchronized (ll) {
                            System.out.println("线程B 成功锁住 list-1");
                            ll.add(i);
                            System.out.println("线程B 成功添加元素进 list-1");
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            latch.countDown();
        };
        taskExecutor.execute(run2);

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        taskExecutor.shutdown();
    }

console 输出如下：
线程A 开始执行
线程A 尝试锁住 list-1
线程A 成功锁住 list-1
线程A 成功添加元素进 list-1
线程B 开始执行
线程B 尝试锁住 list-2
线程B 成功锁住 list-2
线程B 成功添加元素进 list-2
线程B 尝试锁住 list-1
线程A 尝试锁住 list-2

解决

// todo