DeadLock进程首先锁定哪一个？

Question

考虑以下:

public class Deadlock {
static class Friend{
    private final String name;

    public Friend (String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }


    public synchronized void bow(Friend bower){
        System.out.format("\n%S: %S has bowed to me!" , this.name, bower.getName());
        bower.bowBack(this);
    }
    public synchronized void bowBack(Friend bower) {
        System.out.format("\n%S: %S has bowed back to me!", this.name, bower.getName());
    }


}

public static void main(String[] args) {
    final Friend alf = new Friend("Alf");
    final Friend arian = new Friend("Arian");

    // Thread 1
             new Thread(new Runnable()  {
        public void run(){ alf.bow(arian);}}).start();

    //Thread 2
    new Thread(new Runnable()  {
        public void run(){ arian.bow(alf);}}).start();  
}

}

输出是

ALF:ARIAN向我鞠躬致敬!ARIAN:ALF向我鞠躬致敬!

锁定情况.....

当线程1运行时,它需要锁定对象Friend.紧接着线程2需要锁定第二个对象.现在方法弓 由线1锁定,因此打印"ALF:ARIAN向我鞠躬!".线程2如何进入弓形,两者都不能进入*bowBack* ??

问候B.

Answer 1

请记住,synchronized方法将始终同步this.

有两个对象,因此有两个锁.alf.bow()获得alf锁定并arian.bow()获得arians.但后来bowback()试图获得另一个,即僵​​局发生时.

如果要在共享锁对象上进行同步,则应执行以下操作:

class Friend {
   private static final Object lock = new Object();

   public void bow(...) {
     synchronized( lock ) {
        ...
     }
   }

   public void bowback(...) {
     synchronized( lock ) {
        ...
     }
   }

}

由于lock是在静态字段中,它意味着所有Friend使用相同锁对象的实例,因此不存在死锁的可能性.

您也可以在类对象上进行同步synchronized( Friend.class ) {...},但在外部可见对象上进行同步通常不是一个好主意,因为无法保证代码的其他部分不会窃取锁.