关于Java中的死锁情况的问题

问题描述

我正在学习Java中的死锁，这里有来自Sun官方教程的示例代码：

  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（％s：％s向我屈服！％n，
 this.name ，bower.getName（））; 
 bower.bowBack（this）; 
} 
 public synchronized void bowBack（Friend bower）{
 System.out.format（％s：％s已经回到我！％n，
这个。 name，bower.getName（））; 
} 
} 
 
 public static void main（String [] args）{
 final Friend alphonse = new Friend（Alphonse）; 
 final Friend gaston = new Friend（Gaston）; 
 new Thread（new Runnable（）{
 public void run（）{alphonse.bow（gaston）;} 
}）。 
 new Thread（new Runnable（）{
 public void run（）{gaston.bow（alphonse）;} 
}）。 
} 
} 
  

这里是Sun的解释：

我似乎不太喜欢。当alphonse.bow（gaston）运行时，bow方法被锁定。所以现在它会先打印Gaston向我has了！然后它会继续，并调用bowBack，并锁定bowBack以及。这怎么会导致死锁？我是否误解当同步方法被调用时会发生什么？

如果有人可以给我一个简单的解释，谢谢。

解决方案

需要注意的一点是，它不是被锁定的方法，而是对象实例。

当调用 alphonse.bow（gaston）时，它会尝试获取 alphonse 。一旦它有锁，它打印一个消息，然后调用 gaston.bowBack（alphonse）。此时，它尝试获取 gaston 上的锁。一旦它有锁，它打印一个消息，然后释放锁，最后锁定 alphonse 被释放。

• 线程1：获取所有线程锁定 alphonse


• 主题2：取得 gaston >
  
• 主题1：打印邮件


• 主题1：尝试在 gaston


• 线程2：尝试获取 alphonse上的锁定 - 不能，因为第1个线程已有它。

I'm learning about deadlocks in Java, and there's this sample code from Sun's official tutorial:

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("%s: %s has bowed to me!%n", 
                    this.name, bower.getName());
            bower.bowBack(this);
        }
        public synchronized void bowBack(Friend bower) {
            System.out.format("%s: %s has bowed back to me!%n",
                    this.name, bower.getName());
        }
    }

    public static void main(String[] args) {
        final Friend alphonse = new Friend("Alphonse");
        final Friend gaston = new Friend("Gaston");
        new Thread(new Runnable() {
            public void run() { alphonse.bow(gaston); }
        }).start();
        new Thread(new Runnable() {
            public void run() { gaston.bow(alphonse); }
        }).start();
    }
}

Here's Sun's explanation:

I don't quite seem to follow. When alphonse.bow(gaston) runs, the bow method is locked. So now it'll first print "Gaston has bowed to me!". Then it'll go on and call bowBack, and locks bowBack as well. How can this cause a deadlock? Am I misunderstanding what happens when a synchronized method is called?

If someone can give me a easy explanation, thanks.

解决方案

One important point to note is that it is not methods which are locked but object instances.

When you call alphonse.bow(gaston), it tries to acquire the lock on alphonse. Once it has the lock, it prints a message, then calls gaston.bowBack(alphonse). At this point, it tries to acquire the lock on gaston. Once it has the lock, it prints a message, then releases the lock, and finally the lock on alphonse is released.

In deadlock, the locks are acquired in such an order that there's no way for either thread to proceed.

• Thread 1: acquires lock on alphonse
• Thread 2: acquires lock on gaston
• Thread 1: prints message
• Thread 1: tries to acquire lock on gaston - can't, because Thread 2 already has it.
• Thread 2: prints message
• Thread 2: tries to acquire lock on alphonse - can't, because Thread 1 already has it.

这篇关于关于Java中的死锁情况的问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！