有导致死锁的情况，并建议我如何修复，我需要一般建议

Question

我学习爪哇多线程。有导致死锁的情况，并建议我如何修复，我需要一般建议。我明白什么意味着什么死锁概念，但它可以解决一个问题。这是代码：应用类：// in multithreading. class Util {     // Util class to sleep a thread     static void sleep(long millis)     {         try        {             Thread.sleep(millis);         }         catch (InterruptedException e)         {             e.printStackTrace();         }     } } 共享类：// This class is shared by both threads class Shared {     // first synchronized method     synchronized void test1(Shared s2)     {         System.out.println("test1-begin");         Util.sleep(1000);         // taking object lock of s2 enters         // into test2 method         s2.test2(this);         System.out.println("test1-end");     }     // second synchronized method     synchronized void test2(Shared s1)     {         System.out.println("test2-begin");         Util.sleep(1000);         // taking object lock of s1 enters         // into test1 method         s1.test1(this);         System.out.println("test2-end");     } } java 线程 1 类：class Thread1 extends Thread {     private Shared s1;     private Shared s2;     // constructor to initialize fields     public Thread1(Shared s1, Shared s2)     {         this.s1 = s1;         this.s2 = s2;     }     // run method to start a thread     @Override    public void run()     {         // taking object lock of s1 enters         // into test1 method         s1.test1(s2);     } } java 线程 2 类：class Thread2 extends Thread {     private Shared s1;     private Shared s2;     // constructor to initialize fields     public Thread2(Shared s1, Shared s2)     {         this.s1 = s1;         this.s2 = s2;     }     // run method to start a thread     @Override    public void run()     {         // taking object lock of s2         // enters into test2 method         s2.test2(s1);     } }

Answer 1

您提供的代码确实会导致死锁。最初， 获取 的固有锁，并获取 的锁。然后尝试在仍然持有锁的同时获取锁。由于锁由 持有，将阻止等待锁被释放。类似的情况发生在：它尝试在仍然持有锁的同时获取锁。由于锁由 持有，因此也会阻塞。这会导致僵局。t1s1t2s2t1s2s1s2t2t1t2s1s2s1t1t2

要解决此问题，两个线程应仅使用一个锁来同步其工作。一个可能的解决方案是：

class Shared

{

    private static final Object LOCK = new Object();

    // first synchronized method

    void test1(Shared s2)

    {

        synchronized (LOCK) {

            System.out.println("test1-begin");

            Util.sleep(1000);

            // taking object lock of s2 enters

            // into test2 method

            s2.test2(this);

            System.out.println("test1-end");

        }

    }

    // second synchronized method

    void test2(Shared s1)

    {

        synchronized (LOCK) {

            System.out.println("test2-begin");

            Util.sleep(1000);

            // taking object lock of s1 enters

            // into test1 method

            s1.test1(this);

            System.out.println("test2-end");

        }

    }

}

这将修复死锁。但是，考虑到当前的实现，它将导致间接递归引起的无限循环：->->->->...s1.test1(s2)s2.test2(s1)s1.test1(s2)s2.test2(s1)