Deadlock in Java is een onderdeel van multithreading. Deadlock kan optreden in een situatie waarin een thread wacht op een objectvergrendeling, die is verkregen door een andere thread, en een tweede thread wacht op een objectvergrendeling die is verkregen door de eerste thread. Omdat beide threads op elkaar wachten om de vergrendeling op te heffen, wordt deze toestand deadlock genoemd.
Voorbeeld van een impasse op Java
TestDeadlockExample1.java
Junit-testgevallen
public class TestDeadlockExample1 { public static void main(String[] args) { final String resource1 = 'ratan jaiswal'; final String resource2 = 'vimal jaiswal'; // t1 tries to lock resource1 then resource2 Thread t1 = new Thread() { public void run() { synchronized (resource1) { System.out.println('Thread 1: locked resource 1'); try { Thread.sleep(100);} catch (Exception e) {} synchronized (resource2) { System.out.println('Thread 1: locked resource 2'); } } } }; // t2 tries to lock resource2 then resource1 Thread t2 = new Thread() { public void run() { synchronized (resource2) { System.out.println('Thread 2: locked resource 2'); try { Thread.sleep(100);} catch (Exception e) {} synchronized (resource1) { System.out.println('Thread 2: locked resource 1'); } } } }; t1.start(); t2.start(); } } Uitgang:
Thread 1: locked resource 1 Thread 2: locked resource 2
Meer ingewikkelde impasses
Een impasse kan ook meer dan twee threads omvatten. De reden hiervoor is dat het moeilijk kan zijn om een impasse te detecteren. Hier is een voorbeeld waarin vier threads vastlopen:
Draad 1 vergrendelt A, wacht op B
Draad 2 vergrendelt B, wacht op C
Draad 3 vergrendelt C, wacht op D
Linux welke
Draad 4 sloten D, wacht op A
Draad 1 wacht op draad 2, draad 2 wacht op draad 3, draad 3 wacht op draad 4 en draad 4 wacht op draad 1.
verilog altijd
Hoe kan een impasse worden voorkomen?
Een oplossing voor een probleem wordt gevonden bij de wortels. In een impasse is het patroon van toegang tot de bronnen A en B het belangrijkste probleem. Om het probleem op te lossen, zullen we eenvoudigweg de instructies waarin de code toegang heeft tot gedeelde bronnen opnieuw moeten rangschikken.
DeadlockSolved.java
public class DeadlockSolved { public static void main(String ar[]) { DeadlockSolved test = new DeadlockSolved(); final resource1 a = test.new resource1(); final resource2 b = test.new resource2(); // Thread-1 Runnable b1 = new Runnable() { public void run() { synchronized (b) { try { /* Adding delay so that both threads can start trying to lock resources */ Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // Thread-1 have resource1 but need resource2 also synchronized (a) { System.out.println('In block 1'); } } } }; // Thread-2 Runnable b2 = new Runnable() { public void run() { synchronized (b) { // Thread-2 have resource2 but need resource1 also synchronized (a) { System.out.println('In block 2'); } } } }; new Thread(b1).start(); new Thread(b2).start(); } // resource1 private class resource1 { private int i = 10; public int getI() { return i; } public void setI(int i) { this.i = i; } } // resource2 private class resource2 { private int i = 20; public int getI() { return i; } public void setI(int i) { this.i = i; } } } Uitgang:
In block 1 In block 2
In de bovenstaande code lost de klasse DeadlockSolved de impasse-achtige situatie op. Het zal helpen bij het vermijden van impasses, en als deze zich voordoen, bij het oplossen ervan.
Hoe vermijd je een impasse in Java?
Impasses kunnen niet volledig worden opgelost. Maar we kunnen ze vermijden door de onderstaande basisregels te volgen: