Java多线程并发编程：锁机制可能导致的死锁问题实例

原创怼烎@ 2024-11-23 14:24 1阅读 0赞

在Java多线程编程中，锁机制是控制共享资源访问的重要手段。但是，过度使用或管理不当可能会导致死锁问题。

以下是一个死锁实例：

```java
// 定义两个互斥资源
class Resource1 {
    Lock lock = new Lock();

void acquire() { lock.lock(); }
    void release() { lock.unlock(); }
}

class Resource2 {
    Lock lock = new Lock();

void acquire() { lock.lock(); }
    void release() { lock.unlock(); }
}

// 两个线程分别申请资源
class ThreadA extends Thread {
    private Resource1 resource;

ThreadA(Resource1 resource) {
        this.resource = resource;
    }

public void run() {
        try {
            // 线程A先申请资源1
            resource.acquire();
            System.out.println("Thread A acquired Resource 1");

// 等待一段时间，让线程B有机会申请资源2
            Thread.sleep(3000);

// 线程A再申请资源2
            resource.acquire();
            System.out.println("Thread A acquired Resource 2");

} catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 线程A释放所有资源
            resource.release();
            resource.release(); // 如果需要同时释放两个资源

System.out.println("Thread A finished");
        }
    }
}

class ThreadB extends Thread {
    private Resource2 resource;

ThreadB(Resource2 resource) {
        this.resource = resource;
    }

public void run() {
        try {
            // 线程B先申请资源2
            resource.acquire();
            System.out.println("Thread B acquired Resource 2");

// 等待一段时间，让线程A有机会申请资源1
            Thread.sleep(3000);

// 线程B再申请资源1
            resource.acquire();
            System.out.println("Thread B acquired Resource 1");

} catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 线程B释放所有资源
            resource.release();
            resource.release(); // 如果需要同时释放两个资源

System.out.println("Thread B finished");
        }
    }
}

// 创建并启动线程A和线程B
public static void main(String[] args) {
    Resource1 resource1 = new Resource1();
    ThreadA threadA = new ThreadA(resource1);
    ThreadB threadB = new ThreadB(resource2);

// 启动线程A和线程B
    threadA.start();
    threadB.start();

System.out.println("主线程结束");
}
```

在这个例子中，两个线程分别请求资源1和资源2。但是，因为资源的互斥性（每个资源只能被一个线程占用），线程B在申请资源1后，资源1由线程A持有，线程B无法再申请资源1。同样的情况发生在线程A对资源2的申请过程中。结果是两个线程都进入了死锁状态。