use*_*434 83 java concurrency deadlock
我最近在接受采访时提到了这个问题.
我回答说如果交错出错就会发生死锁,但是访问者坚持认为可以编写一个总是会陷入死锁的程序而不管交错.
我们可以写这样的程序吗？你能指点我这样的示例程序吗？
Eri*_*ert 96
更新:这个问题是我2013年1月的博客主题.谢谢你这个好问题!
无论线程如何安排,我们如何编写一个永远陷入死锁的程序？
这是C#中的一个例子.请注意,该程序似乎不包含锁,也没有共享数据.它只有一个局部变量和三个语句,但它有100%的确定性死锁.人们很难想出一个更加简单的程序,它可以确定地陷入僵局.
向读者练习#1:解释这种僵局.(答案在评论中.)
练习读者#2:在Java中演示相同的死锁.(答案在这里:https://stackoverflow.com/a/9286697/88656)
class MyClass
{
static MyClass()
{
// Let's run the initialization on another thread!
var thread = new System.Threading.Thread(Initialize);
thread.Start();
thread.Join();
}
static void Initialize()
{ /* TODO: Add initialization code */ }
static void Main()
{ }
}
art*_*tol 27
这里的锁存器确保当每个线程试图锁定另一个时,两个锁都被保持:
import java.util.concurrent.CountDownLatch;
public class Locker extends Thread {
private final CountDownLatch latch;
private final Object obj1;
private final Object obj2;
Locker(Object obj1, Object obj2, CountDownLatch latch) {
this.obj1 = obj1;
this.obj2 = obj2;
this.latch = latch;
}
@Override
public void run() {
synchronized (obj1) {
latch.countDown();
try {
latch.await();
} catch (InterruptedException e) {
throw new RuntimeException();
}
synchronized (obj2) {
System.out.println("Thread finished");
}
}
}
public static void main(String[] args) {
final Object obj1 = new Object();
final Object obj2 = new Object();
final CountDownLatch latch = new CountDownLatch(2);
new Locker(obj1, obj2, latch).start();
new Locker(obj2, obj1, latch).start();
}
}
有意运行jconsole,它会在Threads选项卡中正确显示死锁.
Gre*_*tes 24
当线程(或任何平台调用其执行单元)获取资源时,就会发生死锁,其中每个资源一次只能由一个线程持有,并以这样的方式保留这些资源,使得无法抢占保留,以及线程之间存在一些"循环"关系,使得死锁中的每个线程都在等待获取另一个线程持有的某些资源.
因此,避免死锁的一种简单方法是对资源进行一些总排序,并强制规定资源只能由线程按顺序获取.相反,可以通过运行获取资源的线程有意地创建死锁,但不要按顺序获取它们.例如:
两个线程,两个锁.第一个线程运行一个循环,尝试以某种顺序获取锁,第二个线程运行一个循环,尝试以相反的顺序获取锁.成功获取锁后,每个线程都释放两个锁.
public class HighlyLikelyDeadlock {
static class Locker implements Runnable {
private Object first, second;
Locker(Object first, Object second) {
this.first = first;
this.second = second;
}
@Override
public void run() {
while (true) {
synchronized (first) {
synchronized (second) {
System.out.println(Thread.currentThread().getName());
}
}
}
}
}
public static void main(final String... args) {
Object lock1 = new Object(), lock2 = new Object();
new Thread(new Locker(lock1, lock2), "Thread 1").start();
new Thread(new Locker(lock2, lock1), "Thread 2").start();
}
}
现在,在这个问题中有一些评论指出了死锁的可能性和确定性之间的区别.从某种意义上说,这种区别是一个学术问题.从实际的角度来看,我当然希望看到一个正在运行的系统,它与我上面编写的代码没有死锁:)
然而,面试问题有时可能是学术性的,而这个问题确实在标题中有"肯定"这个词,所以接下来的是一个肯定会陷入僵局的程序.Locker创建了两个对象,每个对象都有两个锁,一个CountDownLatch用于在线程之间进行同步.每个Locker锁定第一个锁,然后对锁闩计数一次.当两个线程都已获得锁定并向下计数锁存器时,它们继续经过锁存屏障并尝试获取第二个锁定,但在每种情况下,另一个线程已经保持所需的锁定.这种情况导致一定的死锁.
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CertainDeadlock {
static class Locker implements Runnable {
private CountDownLatch latch;
private Lock first, second;
Locker(CountDownLatch latch, Lock first, Lock second) {
this.latch = latch;
this.first = first;
this.second = second;
}
@Override
public void run() {
String threadName = Thread.currentThread().getName();
try {
first.lock();
latch.countDown();
System.out.println(threadName + ": locked first lock");
latch.await();
System.out.println(threadName + ": attempting to lock second lock");
second.lock();
System.out.println(threadName + ": never reached");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public static void main(final String... args) {
CountDownLatch latch = new CountDownLatch(2);
Lock lock1 = new ReentrantLock(), lock2 = new ReentrantLock();
new Thread(new Locker(latch, lock1, lock2), "Thread 1").start();
new Thread(new Locker(latch, lock2, lock1), "Thread 2").start();
}
}
Yur*_*rev 14
以下是Eric Lippert的一个Java示例:
public class Lock implements Runnable {
static {
System.out.println("Getting ready to greet the world");
try {
Thread t = new Thread(new Lock());
t.start();
t.join();
} catch (InterruptedException ex) {
System.out.println("won't see me");
}
}
public static void main(String[] args) {
System.out.println("Hello World!");
}
public void run() {
Lock lock = new Lock();
}
}
Clo*_*ble 11
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();
}
}
我重写了Yuriy Zubarev的Java版本的Eric Lippert发布的死锁示例:https://stackoverflow.com/a/9286697/2098232 更接近C#版本.如果Java的初始化块与C#静态构造函数类似,并且首先获取锁,我们不需要另一个线程来调用join方法来获取死锁,它只需要从Lock类调用一些静态方法,就像原来的C#一样例.造成的死锁似乎证实了这一点.
public class Lock {
static {
System.out.println("Getting ready to greet the world");
try {
Thread t = new Thread(new Runnable(){
@Override
public void run() {
Lock.initialize();
}
});
t.start();
t.join();
} catch (InterruptedException ex) {
System.out.println("won't see me");
}
}
public static void main(String[] args) {
System.out.println("Hello World!");
}
public static void initialize(){
System.out.println("Initializing");
}
}
这不是一个你可以得到的最简单的面试任务:在我的项目中,它使一个团队的工作陷入瘫痪一整天.让程序停止很容易,但是很难让它进入线程转储写入的状态,
Found one Java-level deadlock:
=============================
"Thread-2":
waiting to lock monitor 7f91c5802b58 (object 7fb291380, a java.lang.String),
which is held by "Thread-1"
"Thread-1":
waiting to lock monitor 7f91c6075308 (object 7fb2914a0, a java.lang.String),
which is held by "Thread-2"
Java stack information for the threads listed above:
===================================================
"Thread-2":
at uk.ac.ebi.Deadlock.run(Deadlock.java:54)
- waiting to lock <7fb291380> (a java.lang.String)
- locked <7fb2914a0> (a java.lang.String)
- locked <7f32a0760> (a uk.ac.ebi.Deadlock)
at java.lang.Thread.run(Thread.java:680)
"Thread-1":
at uk.ac.ebi.Deadlock.run(Deadlock.java:54)
- waiting to lock <7fb2914a0> (a java.lang.String)
- locked <7fb291380> (a java.lang.String)
- locked <7f32a0580> (a uk.ac.ebi.Deadlock)
at java.lang.Thread.run(Thread.java:680)
因此,目标是获得JVM认为会陷入僵局的死锁.显然,没有解决方案
synchronized (this) {
wait();
}
从那个意义上来说,即使他们确实会永远停止.依靠竞争条件也不是一个好主意,因为在面试中你通常想要展示一些可以证明有效的东西,而不是大部分时间应该起作用的东西.
现在,sleep()解决方案在某种意义上是可以的,很难想象它不起作用的情况,但不公平(我们在公平的运动中,不是吗？).@artbristol的解决方案(我的是相同的,只是作为监视器的不同对象)很好,但很长并且使用新的并发原语来使线程处于正确的状态,这不是那么有趣:
public class Deadlock implements Runnable {
private final Object a;
private final Object b;
private final static CountDownLatch latch = new CountDownLatch(2);
public Deadlock(Object a, Object b) {
this.a = a;
this.b = b;
}
public synchronized static void main(String[] args) throws InterruptedException {
new Thread(new Deadlock("a", "b")).start();
new Thread(new Deadlock("b", "a")).start();
}
@Override
public void run() {
synchronized (a) {
latch.countDown();
try {
latch.await();
} catch (InterruptedException ignored) {
}
synchronized (b) {
}
}
}
}
我记得,synchronized只有解决方案适合11..13行代码(不包括评论和导入),但还没有回忆起实际的技巧.如果我这样做会更新.
更新:这是一个丑陋的解决方案synchronized:
public class Deadlock implements Runnable {
public synchronized static void main(String[] args) throws InterruptedException {
synchronized ("a") {
new Thread(new Deadlock()).start();
"a".wait();
}
synchronized ("") {
}
}
@Override
public void run() {
synchronized ("") {
synchronized ("a") {
"a".notifyAll();
}
synchronized (Deadlock.class) {
}
}
}
}
注意我们用对象监视器替换一个锁存器("a"用作对象).
| 归档时间： |
|
| 查看次数： |
31135 次 |
| 最近记录： |