確実にデッドロック状態になるプログラムを書く
最近、インタビューでこの質問を受けました。
インタリーブがうまくいかないとデッドロックが発生すると答えましたが、インタビュアーはインタリーブに関係なく常にデッドロックになるプログラムを書くことができると主張しました。
そのようなプログラムを書くことはできますか？そのようなプログラム例を教えていただけますか？
更新： この質問は2013年1月の私のブログの主題でした 。すばらしい質問をありがとう！
スレッドのスケジュールに関係なく、常にデッドロック状態になるプログラムを作成するにはどうすればよいですか？
C＃の例を次に示します。 プログラムにはロックも共有データも含まれていないように見えることに注意してください。1つのローカル変数と3つのステートメントしかありませんが、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()
{ }
}
ここでのラッチにより、各スレッドが他のスレッドをロックしようとしたときに両方のロックが保持されることが保証されます。
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を実行すると、スレッドタブにデッドロックが正しく表示されます。
デッドロックが発生します スレッド（またはプラットフォームが実行ユニットと呼ぶもの）がリソースを取得する場合、各リソースは一度に1つのスレッドのみが保持でき、次のような方法でそれらのリソースを保持します保留をプリエンプトすることはできません。また、デッドロック内の各スレッドが別のスレッドによって保持されているリソースの取得を待機するように、スレッド間に何らかの「循環」関係が存在します。
したがって、デッドロックを回避する簡単な方法は、リソースにtotal orderingを与え、リソースがスレッドによってのみ取得されるというルールを課すことですin order。逆に、デッドロックは、リソースを取得するが順番に取得しないスレッドを実行することにより、意図的に作成することができます。例えば：
2つのスレッド、2つのロック。最初のスレッドは特定の順序でロックを取得しようとするループを実行し、2番目のスレッドは反対の順序でロックを取得しようとするループを実行します。各スレッドは、ロックを正常に取得した後、両方のロックを解放します。
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();
}
}
さて、この質問には、デッドロックのlikelihoodとcertaintyの違いを指摘するコメントがいくつかありました。ある意味では、区別は学術的な問題です。実用的な観点からは、上で書いたコードでデッドロックしない稼働中のシステムを見たいと思います:)
ただし、面接の質問は時々学術的であり、このSO質問にはタイトルに「確実に」という単語が含まれているので、次のプログラムは確かにデッドロック。2つのLockerオブジェクトが作成され、それぞれに2つのロックと、スレッド間の同期に使用されるCountDownLatchが与えられます。各Lockerは最初のロックをロックし、ラッチを1回カウントダウンします。ロックを取得してラッチをカウントダウンすると、ラッチバリアを通過して2番目のロックを取得しようとしますが、いずれの場合も、他のスレッドは既に目的のロックを保持しています。この状況はcertainデッドロック。
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();
}
}
以下に、Java 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();
}
}
ここに例があります ドキュメントから：
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();
}
}
Eric Lippertが投稿したデッドロックの例のYuriy ZubarevのJavaバージョンを書き直しました： https://stackoverflow.com/a/9286697/2098232 C＃バージョンにより似たものにする。 Javaの初期化ブロックがC＃静的コンストラクターと同様に機能し、最初にロックを取得する場合、デッドロックを取得するためにjoinメソッドを呼び出す別のスレッドは必要ありません。元のC＃のように、Lockクラスから静的メソッドを呼び出すだけです例。その結果、デッドロックがこれを確認しているようです。
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");
}
}
それはあなたが得ることができる最も単純なインタビューの仕事ではありません：私のプロジェクトでは、それは一日中チームの仕事を麻痺させました。プログラムを停止させるのは非常に簡単ですが、 thread dump のような状態になるのは非常に困難です。
_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"_を使用）。
このC＃バージョンは、Javaはかなり似ているはずです。
static void Main(string[] args)
{
var mainThread = Thread.CurrentThread;
mainThread.Join();
Console.WriteLine("Press Any key");
Console.ReadKey();
}
import Java.util.concurrent.CountDownLatch;
public class SO8880286 {
public static class BadRunnable implements Runnable {
private CountDownLatch latch;
public BadRunnable(CountDownLatch latch) {
this.latch = latch;
}
public void run() {
System.out.println("Thread " + Thread.currentThread().getId() + " starting");
synchronized (BadRunnable.class) {
System.out.println("Thread " + Thread.currentThread().getId() + " acquired the monitor on BadRunnable.class");
latch.countDown();
while (true) {
try {
latch.await();
} catch (InterruptedException ex) {
continue;
}
break;
}
}
System.out.println("Thread " + Thread.currentThread().getId() + " released the monitor on BadRunnable.class");
System.out.println("Thread " + Thread.currentThread().getId() + " ending");
}
}
public static void main(String[] args) {
Thread[] threads = new Thread[2];
CountDownLatch latch = new CountDownLatch(threads.length);
for (int i = 0; i < threads.length; ++i) {
threads[i] = new Thread(new BadRunnable(latch));
threads[i].start();
}
}
}
各スレッドは他のスレッドのバリアで待機しているため、プログラムは常にデッドロックしますが、バリアを待機するには、スレッドがBadRunnable.classでモニターを保持している必要があります。
Javaここに例があります
http://baddotrobot.com/blog/2009/12/24/deadlock/
誘kid犯が現金を受け取るまで被害者を放棄することを拒否したが、交渉者が被害者を取得するまで現金を放棄することを拒否した場合、誘n犯はデッドロックに陥ります。
以下は、ロックを保持している1つのスレッドが同じロックを必要とする別のスレッドを開始し、スターターが開始が完了するまで待機するサンプルです...
class OuterTask implements Runnable {
private final Object lock;
public OuterTask(Object lock) {
this.lock = lock;
}
public void run() {
System.out.println("Outer launched");
System.out.println("Obtaining lock");
synchronized (lock) {
Thread inner = new Thread(new InnerTask(lock), "inner");
inner.start();
try {
inner.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class InnerTask implements Runnable {
private final Object lock;
public InnerTask(Object lock) {
this.lock = lock;
}
public void run() {
System.out.println("Inner launched");
System.out.println("Obtaining lock");
synchronized (lock) {
System.out.println("Obtained");
}
}
}
class Sample {
public static void main(String[] args) throws InterruptedException {
final Object outerLock = new Object();
OuterTask outerTask = new OuterTask(outerLock);
Thread outer = new Thread(outerTask, "outer");
outer.start();
outer.join();
}
}
簡単な検索で次のコードが得られました。
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();
}
}
ソース： デッドロック
以下に例を示します。
2つのスレッドが実行されており、それぞれが他のスレッドがロックを解除するのを待っています
パブリッククラスThreadClassはThread {を拡張します
String obj1,obj2;
ThreadClass(String obj1,String obj2){
this.obj1=obj1;
this.obj2=obj2;
start();
}
public void run(){
synchronized (obj1) {
System.out.println("lock on "+obj1+" acquired");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("waiting for "+obj2);
synchronized (obj2) {
System.out.println("lock on"+ obj2+" acquired");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
これを実行すると、デッドロックが発生します。
パブリッククラスSureDeadlock {
public static void main(String[] args) {
String obj1= new String("obj1");
String obj2= new String("obj2");
new ThreadClass(obj1,obj2);
new ThreadClass(obj2,obj1);
}
}