Deadlock ist eine Situation, in der mehrere Threads gleichzeitig blockiert sind und einer oder alle auf die Freigabe einer Ressource warten. Da der Thread auf unbestimmte Zeit blockiert ist, kann das Programm nicht ordnungsgemäß beendet werden.
Vier notwendige Bedingungen für einen Java-Deadlock:
1> Sich gegenseitig ausschließende Nutzung, das heißt, wenn eine Ressource von einem Thread verwendet (belegt) wird, können andere Threads sie nicht verwenden
2> Ressourcenanforderer können keine Ressourcen von Ressourcennutzern erzwingen. Ressourcen können nur aktiv von Ressourcennutzern freigegeben werden.
3> Anfordern und pflegen, das heißt, wenn der Ressourcenanforderer andere Ressourcen anfordert und gleichzeitig Kameraden in den ursprünglichen Ressourcen beibehält.
4> Schleifenwarteschlange, das heißt, es gibt eine Warteschlange: P1 belegt die Ressourcen von P2, P2 belegt die Ressourcen von P3 und P3 belegt die Ressourcen von P1. Dadurch entsteht eine Warteschleife.
Wenn die oben genannten vier Bedingungen zutreffen, entsteht ein Deadlock. Im Falle eines Deadlocks verschwindet der Deadlock natürlich, wenn eine der oben genannten Bedingungen verletzt wird. Lassen Sie uns Java-Code verwenden, um das Auftreten eines Deadlocks zu simulieren.
Die Möglichkeiten, das Deadlock-Problem zu lösen, sind: Eine besteht darin, synchronisiert zu verwenden, und die andere darin, die explizite Sperrimplementierung von Lock zu verwenden.
Wenn Sperren unsachgemäß verwendet werden und mehrere Objekte gleichzeitig gesperrt sind, kommt es wie folgt zu einer Deadlock-Situation:
/*
author by w3cschool.cc
LockTest.java
*/import java.util.Date;public class LockTest {
public static String obj1 = "obj1";
public static String obj2 = "obj2";
public static void main(String[] args) {
LockA la = new LockA();
new Thread(la).start();
LockB lb = new LockB();
new Thread(lb).start();
}}class LockA implements Runnable{
public void run() {
try {
System.out.println(new Date().toString() + " LockA 开始执行");
while(true){
synchronized (LockTest.obj1) {
System.out.println(new Date().toString() + " LockA 锁住 obj1");
Thread.sleep(3000); // 此处等待是给B能锁住机会
synchronized (LockTest.obj2) {
System.out.println(new Date().toString() + " LockA 锁住 obj2");
Thread.sleep(60 * 1000); // 为测试，占用了就不放
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}}class LockB implements Runnable{
public void run() {
try {
System.out.println(new Date().toString() + " LockB 开始执行");
while(true){
synchronized (LockTest.obj2) {
System.out.println(new Date().toString() + " LockB 锁住 obj2");
Thread.sleep(3000); // 此处等待是给A能锁住机会
synchronized (LockTest.obj1) {
System.out.println(new Date().toString() + " LockB 锁住 obj1");
Thread.sleep(60 * 1000); // 为测试，占用了就不放
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}}Das Ausgabeergebnis des obigen Codes ist:
Tue May 05 10:51:06 CST 2015 LockB 开始执行 Tue May 05 10:51:06 CST 2015 LockA 开始执行 Tue May 05 10:51:06 CST 2015 LockB 锁住 obj2 Tue May 05 10:51:06 CST 2015 LockA 锁住 obj1
Zu diesem Zeitpunkt tritt ein Deadlock auf.
Um dieses Problem zu lösen, verwenden wir keine explizite Entsperrung, sondern eine Semaphorsteuerung.
Das Semaphor kann steuern, wie viele Threads auf die Ressource zugreifen können. Hier geben wir an, dass nur ein Thread darauf zugreifen kann, was einer Sperre ähnelt. Das Semaphor kann den Timeout-Zeitraum für die Erfassung angeben, und wir können basierend auf diesem Timeout-Zeitraum weitere Verarbeitungen durchführen.
Wenn Sie es nicht erfolgreich erhalten, können Sie es normalerweise erneut versuchen, die Anzahl der Versuche angeben oder sofort beenden.
Sehen wir uns den folgenden Code an:
/*
author by w3cschool.cc
UnLockTest.java
*/import java.util.Date;import java.util.concurrent.Semaphore;import java.util.concurrent.TimeUnit;public class UnLockTest {
public static String obj1 = "obj1";
public static final Semaphore a1 = new Semaphore(1);
public static String obj2 = "obj2";
public static final Semaphore a2 = new Semaphore(1);
public static void main(String[] args) {
LockAa la = new LockAa();
new Thread(la).start();
LockBb lb = new LockBb();
new Thread(lb).start();
}}class LockAa implements Runnable {
public void run() {
try {
System.out.println(new Date().toString() + " LockA 开始执行");
while (true) {
if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
System.out.println(new Date().toString() + " LockA 锁住 obj1");
if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
System.out.println(new Date().toString() + " LockA 锁住 obj2");
Thread.sleep(60 * 1000); // do something
}else{
System.out.println(new Date().toString() + "LockA 锁 obj2 失败");
}
}else{
System.out.println(new Date().toString() + "LockA 锁 obj1 失败");
}
UnLockTest.a1.release(); // 释放
UnLockTest.a2.release();
Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的
}
} catch (Exception e) {
e.printStackTrace();
}
}}class LockBb implements Runnable {
public void run() {
try {
System.out.println(new Date().toString() + " LockB 开始执行");
while (true) {
if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
System.out.println(new Date().toString() + " LockB 锁住 obj2");
if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
System.out.println(new Date().toString() + " LockB 锁住 obj1");
Thread.sleep(60 * 1000); // do something
}else{
System.out.println(new Date().toString() + "LockB 锁 obj1 失败");
}
}else{
System.out.println(new Date().toString() + "LockB 锁 obj2 失败");
}
UnLockTest.a1.release(); // 释放
UnLockTest.a2.release();
Thread.sleep(10 * 1000); // 这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁
}
} catch (Exception e) {
e.printStackTrace();
}
}}Die Ausgabestruktur des obigen Beispielcodes lautet:
Tue May 05 10:59:13 CST 2015 LockA 开始执行 Tue May 05 10:59:13 CST 2015 LockB 开始执行 Tue May 05 10:59:13 CST 2015 LockB 锁住 obj2 Tue May 05 10:59:13 CST 2015 LockA 锁住 obj1 Tue May 05 10:59:14 CST 2015LockB 锁 obj1 失败 Tue May 05 10:59:14 CST 2015LockA 锁 obj2 失败 Tue May 05 10:59:15 CST 2015 LockA 锁住 obj1 Tue May 05 10:59:15 CST 2015 LockA 锁住 obj2
Das Obige ist der Inhalt des Java-Beispiel - Deadlock und Lösung. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!
