Java Beispiele - Deadlock und Lösung
Deadlock ist eine Situation: mehrere Threads blockiert sind, eine oder alle von ihnen warten auf eine Ressource freigegeben werden. Da der Faden auf unbestimmte Zeit blockiert wird, so kann das Programm nicht normal beendet werden.
Vier notwendigen Bedingungen java Deadlock:
- 1, die exklusive Nutzung, das heißt, wenn die Ressource ein Gewinde (Besitz) ist, andere Threads können nicht verwendet werden
- 2, kann die Ressource Anforderer nicht ergreifen kann nicht aus den Händen der Besitz von Ressourcen, Ressourcen, Ressourcen nur durch die Initiative Insassen freigegeben werden kann, zu ergreifen Ressourcen gezwungen werden.
- 3, Anfragen und behaupten, daß, wenn die Ressource Anforderer während Bitte um zusätzliche Ressourcen Besitz der ursprünglichen Ressource zu erhalten.
- 4, Zyklus warten, das heißt, es gibt eine Warteschlange: P1 P2 nimmt Ressourcen, P2 und P3 Ressourcen Besitz, die P1-P3 Anteil der Ressourcen. So eine Warteschleife zu bilden.
Wenn diese vier Bedingungen erfüllt sind, dann wird ein Deadlock. Natürlich, wenn der Fall eines Deadlocks eine dieser Bedingungen zu brechen, können Sie die Deadlock verschwinden lassen. Verwenden Sie den folgenden Code zu simulieren, was produzieren Deadlock Java.
Lösung für das Deadlock-Problem ist: Die eine ist synchronisiert, ist eine explizite Sperren für Sperren zu verwenden.
Wenn unsachgemäße Verwendung von Sperren, und der Bildschirm zur gleichen Zeit, wenn Sie mehrere Objekte sperren wollen, wird es eine Deadlock-Situation sein, wie folgt:
/*
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();
}
}
}
Der obige Code ausgeführt wird, ausgegeben wird:
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
An dieser Sackgasse.
Um dieses Problem zu lösen, verwenden wir, um die Sperren nicht angezeigt werden, verwenden wir Semaphoren zu steuern.
Semaphore können steuern, wie viele Threads Ressourcen zugreifen können, die wir hier angeben, nur ein Thread Zugriff sein kann, was Sie tun einen ähnlichen Verschluss. Die Semaphore kann ein Timeout angeben zu bekommen, können wir nach dem Time-out, machen eine zusätzliche Behandlung.
Der Fall kann nicht erhalten, die allgemeine, ist der Versuch, oder geben Sie die Anzahl der Versuche zu wiederholen, können Sie sofort zu verlassen.
Schauen Sie sich den folgenden Code:
/*
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();
}
}
}
Beispiele für die oben genannten Code Ausgabestruktur:
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