尝试检测自己创建的死锁

Question

我写了下面的 Java 代码来创建死锁，我将一个资源字符串变量传递给线程并使用 synchronized 块锁定它并设置一个无限在其中循环，以便第一个线程永远不会离开它，因此第二个线程将永远无法访问它。

public class MainClass {

    public static void main(String[] args) {
        String resourcs = "testResource";
        MainClass M = new MainClass();
        Thread firstThread = new Thread(M.new MyThread("First",resourcs));
        Thread seconThread =  new Thread(M.new MyThread("Second",resourcs));
        firstThread.start();
        seconThread.start();

    }

    class MyThread implements Runnable{
        String resource;
        String name;
        public MyThread(String name,String resource) {
            this.resource = resource;
            this.name = name;
        }

        @Override
        public void run() {
            synchronized (resource) {
                while(true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Still working on the thread :"+name);

                }
            }
        }

    }
}

然后在另一个window中，我写了如下检测死锁的代码，

import java.lang.management.ManagementFactory; 
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class DetectDeadLock {
    public static void main(String args[]) {
        ThreadMXBean bean = ManagementFactory.getThreadMXBean();
        long[] threadIds = bean.findDeadlockedThreads();

        if (threadIds != null) {
            ThreadInfo[] infos = bean.getThreadInfo(threadIds);

            for (ThreadInfo info : infos) {
                StackTraceElement[] stack = info.getStackTrace();
                System.out.println("here");
                // Log or store stack trace information.
            }
        }

    }
}

但是看门狗什么也没检测到。

我是否正确创建了死锁？（我想是的，因为控制台只打印第一个线程的代码）
我是否需要等待一段时间（我知道多少）让 'Watch Dog' 代码检测死锁？

Answer 1

您的代码中没有死锁。当两个（或更多）线程互相等待时就会发生死锁。这里不是这种情况。一个线程等待，另一个线程处于活动状态（无限循环，但这并不意味着它死锁了。）

Answer 2

导致死锁的一种方法是乱序同步。这个例子死锁了两个线程，然后使用上面的检查器来找到它们。都可以是运行来自一个main方法。

    final Object a = new Object();
    final Object b = new Object();
    CountDownLatch latch = new CountDownLatch(2);
    
    new Thread(()->{
        System.out.println(Thread.currentThread().getId() + " running");
        synchronized(a){    
            try{
                latch.countDown();
                latch.await();
            } catch(InterruptedException e){
                return;
            }
            synchronized(b){
                System.out.println("no deadlock");  
            }
        }   
        
    }).start();

    
    new Thread(()->{
        System.out.println(Thread.currentThread().getId() + " running");
        synchronized(b){
            try{
                latch.countDown();
                latch.await();
            } catch(InterruptedException e){
                return;
            }
            synchronized(a){
                System.out.println("no deadlock");  
            }
        }   
        
    }).start();

通过添加一个小的延迟，我可以找到两个死锁的线程 ID。

    Thread.sleep(100);
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    long[] threadIds = bean.findDeadlockedThreads();
    for(long id: threadIds){
        System.out.println(id + " deadlocked");
    }

然后输出如下：

18 running

19 running

19 deadlocked

18 deadlocked

中的Thread.sleep可以省略，但是这样就出现了race condition。可能 bean.findDeadlockedThreads(); 会在出现死锁之前发生。即使睡眠也存在竞争条件，但这种情况非常罕见。门闩可以保证。

可以去掉CountDownLatch，但这样线程有时只会死锁。有时，一个线程会在另一个线程开始之前完成。

尝试检测自己创建的死锁

Tried detecting a self created DeadLock

java

multithreading

deadlock