Java Thread Deadlock

原创港控/mmm° 2024-09-18 12:09 38阅读 0赞

In Java, a deadlock occurs when two or more threads are blocked and waiting for each other to release resources. Here's an explanation with common scenarios:

1. Mutual Exclusivity (ME): Each thread requires exclusive access to a resource. If multiple threads try to acquire the same resource, a deadlock can occur.

Example:
```
// Resource 1
Resource1 r1 = new Resource1();

// Thread 1 wants Resource 1
Thread t1 = new Thread(() -> r1.acquireExclusive()));
t1.start();

// Resource 2
Resource2 r2 = new Resource2();

// Thread 2 wants Resource 2
Thread t2 = new Thread(() -> r2.acquireExclusive()));
t2.start();
```
In this example, threads `t1` and `t2` both try to acquire exclusive access to a resource. Since they're requesting the same resources, a deadlock occurs.

2. Circular Wait (CW): In addition to ME, the threads must be involved in a circular pattern, where each thread is waiting for the resource currently held by another thread.

Example:
```
// Resource 1
Resource1 r1 = new Resource1();

// Thread 1 wants Resource 1
Thread t1 = new Thread(() -> r1.acquireExclusive()));
t1.start();

// Thread 2 (waiting for t1's turn)
Thread t2 = new Thread(() -> {
    try {
        r1.acquire();
        System.out.println("Thread 2 acquired and released resource.");
        r1.release();
        System.out.println("Thread 2 released resource.");
        // Now wait for t1 to release its exclusive lock
        t1.join();
        System.out.println("Thread 2 joined and proceeded after t1 released.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
})();
t2.start();

// Thread 3 (waiting for t2's turn)
Thread t3 = new Thread(() -> {
    try {
        r1.acquire();
        System.out.println("Thread 3 acquired and released resource.");
        r1.release();
        System.out.println("Thread 3 released resource.");
        // Now wait for t2 to release its exclusive lock
        t2.join();
        System.out.println("Thread 3 joined and proceeded after t2 released.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
})();
t3.start();
```
In this example, threads `t1`, `t2`, and `t3` all try to acquire exclusive access to resource `r1`. However, they are involved in a circular pattern where each thread is waiting for the resource currently held by another thread.

When all threads start at the same time, a deadlock occurs as each thread is blocked indefinitely, waiting for the other threads to release resources.