logo

Holtpont a Java-ban

A Java holtpontja a multithreading része. Holtpont olyan helyzetben fordulhat elő, amikor egy szál egy objektumzárra vár, amelyet egy másik szál szerez meg, a második szál pedig egy olyan objektumzárra vár, amelyet az első szál szerez meg. Mivel mindkét szál arra vár, hogy feloldják a zárat, ezt a feltételt holtpontnak nevezzük.

Holtpont a Java-ban

Példa holtpontra a Java-ban

TestDeadlockExample1.java

 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(); } } 

Kimenet:

 Thread 1: locked resource 1 Thread 2: locked resource 2 

Bonyolultabb holtpontok

A holtpont kettőnél több szálat is tartalmazhat. Ennek az az oka, hogy nehéz lehet a holtpontot észlelni. Íme egy példa, amelyben négy szál holtpontra jutott:

Az 1-es szál lezárja az A-t, megvárja a B-t

2. szál zárja B, várja a C-t

logikai érték a java karakterlánchoz

3. szál zárja C, várja a D-t

4 szál D zár, várja az A-t

Az 1. szál a 2. szálra, a 2. szál a 3. szálra, a 3. szál a 4. szálra, a 4. szál pedig az 1. szálra vár.

Hogyan kerüljük el a holtpontot?

A probléma megoldása a gyökereknél keresendő. A holtponton az A és B erőforrásokhoz való hozzáférés mintája a fő probléma. A probléma megoldásához egyszerűen újra kell rendeznünk azokat az utasításokat, amelyekben a kód megosztott erőforrásokhoz fér hozzá.

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; } } } 

Kimenet:

 In block 1 In block 2 

A fenti kódban a DeadlockSolved osztály oldja meg a holtpont típusú helyzetet. Segít elkerülni a holtpontokat, és ha találkozunk, akkor azok megoldásában.

Hogyan lehet elkerülni a holtpontot a Java-ban?

A holtpontokat nem lehet teljesen feloldani. De elkerülhetjük őket, ha betartjuk az alábbi alapvető szabályokat:

    Kerülje a beágyazott zárakat: Kerülnünk kell több szál zárolását, ez a fő oka a holtpontnak. Ez általában akkor történik, ha több szálat zárol.Kerülje a szükségtelen zárakat: A zárakat a fontos szálakhoz kell adni. A holtpontot okozó szükségtelen szálak zárolása.Thread Join használata: A holtpont általában akkor következik be, amikor az egyik szál a másik befejezésére vár. Ebben az esetben használhatjuk csatlakozik egy szál maximális időtartamával.