Java并发编程中死锁问题示例

原创骑猪看日落 2024-09-14 15:27 90阅读 0赞

在Java并发编程中，死锁是一个常见的问题。以下是一个简单的死锁示例：

```java
// 定义两个线程
class ThreadOne implements Runnable {
    private Object lockA = new Object();
    private Object lockB = new Object();

@Override
    public void run() {
        synchronized (lockA) {
            System.out.println("Thread One acquired lock A");

try {
                // 为了模拟死锁，这里线程二需要获取到lockB
                synchronized (lockB) {
                    System.out.println("Thread One attempted to acquire lock B");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 释放lockA，以便线程二能够获得
            unlock(lockA);
        }
    }

private void unlock(Object lock) {
        synchronized (lock) {
            System.out.println("Thread One unlocked " + lock);
            lock = null; // 确保不再使用这个锁
        }
    }
}

class ThreadTwo implements Runnable {
    private Object lockB = new Object();

@Override
    public void run() {
        synchronized (lockB) {
            System.out.println("Thread Two acquired lock B");

try {
                // 为了模拟死锁，这里线程一需要获取到lockA
                synchronized (lockA) {
                    System.out.println("Thread Two attempted to acquire lock A");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 释放lockB，以便线程一能够获得
            unlock(lockB));
        }
    }

private void unlock(Object lock) {
        synchronized (lock) {
            System.out.println("Thread Two unlocked " + lock);
            lock = null; // 确保不再使用这个锁
        }
    }
}

// 创建并启动线程
Thread threadOne = new Thread(new ThreadOne()));
Thread threadTwo = new Thread(new ThreadTwo()));

threadOne.start();
threadTwo.start();
```

在这个例子中，两个线程互相等待对方释放锁。这种情况下很容易发生死锁，因为没有一个线程能继续执行而不会导致其他线程无法获取锁。