死锁是发生在每个方法还是每个类？

Question

我有几个同步方法的类First。当线程锁定类First时，它是锁定每个方法还是每个类？例如，下面的代码会发生死锁吗？

public class DeadLockQuestion {

    public static class First{
        public synchronized void a(){

        }
        public synchronized void b(){

        }
        public synchronized void c(){

        }   
        public synchronized void d(){

        }
        public synchronized void e(){

        }       
    }

    public static void main(String... args){
        First f = new First();

        //This code is run in Thread 1
        f.a();
        // End
        //This code is run in Thread 2 simultanously
        f.b();
        //End
        // We have also Threads 3 & 4 & 5 that invoke c,d and e simultanously

    }

}

Answer 1

死锁发生在线程，而不是方法或类。

死锁线程也持有锁，但在这种情况下不可能知道哪些锁，因为您没有演示实际的死锁场景(如果两个线程调用f的同步方法，一个通过，另一个等待；死锁至少需要两个锁)。

Answer 2

要独立地锁定每个方法，请在每个方法中使用同步块，并锁定不同的对象。

如果在类中已经有了适当的对象(防止潜在问题应该是最终的)，则可以使用该对象。如果不创建一个private final Object aLock = new Object();，然后锁定它，例如：

private final Object aLock = new Object();

public void a() {
    synchronized(aLock) {
         // Do stuff that needs the lock
    }
    // do stuff that doesn't need the lock
}

只要你需要，就一定要保持锁，但不要再这样了。

Answer 3

当a()是一个同步方法时，f.a()字面意思是：

synchronized(f){
    f.a();
}

因此，在这种情况下，对象监视器f将发生锁定。在您的情况下，您需要第二个对象来创建死锁，我认为用单个对象监视器创建死锁是不可能的。典型的死锁模式是当锁获取顺序不被维护时，即当这发生在两个不同的线程中时：

synchronized(a){
     synchronized(b){
         ...
     }
}
// and
synchronized(b){
     synchronized(a){
         ...
     }
}