并发控制挑战：Java多线程编程中的锁竞争和死锁问题实例

原创柔情只为你懂 2024-11-15 08:27 50阅读 0赞

在Java多线程编程中，锁竞争和死锁是两个主要的并发控制挑战。

1. 锁竞争：
   这是由于多个线程同时尝试获取同一个锁而出现的问题。例如：
   ```java
   Lock lock = new ReentrantLock();
   Thread thread1 = new Thread(() -> {
       lock.lock(); // 这里可能会发生锁竞争
       try {
           // 线程执行任务
       } finally {
           lock.unlock(); // 无论是否成功获取锁，都需要解锁
       }
     }));
   Thread thread2 = new Thread(() -> {
       lock.lock(); // 此时也可能锁住
       try {
           // 线程执行任务
       } finally {
           lock.unlock(); // 同样需要释放锁
       }
     }));
   thread1.start();
   thread2.start();
   ```
   这个例子中，线程1和线程2同时尝试获取lock锁。这就是锁竞争。

2. 死锁：
   当两个或更多的线程在执行过程中，因争夺资源而造成的一种互相等待的现象称为死锁。例如：
   ```java
   // 假设有一个资源池ResourcePool
   class ResourcePool {
       Lock lock = new ReentrantLock();
       int availableResources = 10; // 先初始化为可用资源数

void requestResource(Thread thread) {
           try {
               lock.lock(); // 获取锁
               if (availableResources > 0) { // 如果资源可用
                   thread资源共享; // 分享资源
                   availableResources--; // 使用后资源减一
               } else {
                   // 资源已用完，线程等待资源释放
                   thread.awaitResourceRelease(); // 阻塞并等待资源释放
               }
           } finally {
               lock.unlock(); // 无论是否成功获取锁，都需要解锁
           }
       }

void releaseResource(Thread thread) {
           try {
               lock.lock(); // 获取锁
               if (availableResources > 0) { // 如果资源可用
                   thread.releaseResource(); // 释放资源
                   availableResources++; // 使用后资源加一
               } else {
                   // 资源已用完，线程等待资源释放
                   thread.awaitResourceRelease(); // 阻塞并等待资源释放
               }
           } finally {
               lock.unlock(); // 无论是否成功获取锁，都需要解锁
           }
       }

void waitForResourceRelease(Thread thread) throws InterruptedException {
           try {
               lock.lock(); // 获取锁
               if (availableResources > 0) { // 如果资源可用
                   thread.join(); // 线程加入阻塞状态
                   // 线程释放资源，然后唤醒其他等待的线程
                   availableResources--; 
                   thread.wakeUp();
                   return; // 跳出方法直接返回，让调用者自行处理后续逻辑
               } else {
                   // 资源已用完，线程等待资源释放
                   thread.awaitResourceRelease(); // 阻塞并等待资源释放
               }
           } finally {
               lock.unlock(); // 无论是否成功获取锁，都需要解锁
           }
       }

public void requestResources(Thread thread) throws InterruptedException {
           try {
               lock.lock(); // 获取锁
               if (availableResources > 0) { // 如果资源可用
                   thread.requestResource(); // 线程请求资源
                   availableResources--; 
                   return; // 跳出方法直接返回，让调用者自行处理后续逻辑
               } else {
                   // 资源已用完，线程等待资源释放
                   thread.awaitResourceRelease(); // 阻塞并等待资源释放
               }
           } finally {
               lock.unlock(); // 无论是否成功获取锁，都需要解锁
           }
       }

public void releaseResources(Thread thread) throws InterruptedException {
           try {
               lock.lock(); // 获取锁
               if (availableResources > 0) { // 如果资源可用
                   thread.releaseResources(); // 线程释放资源
                   availableResources++; 
                   return; // 跳出方法直接返回，让调用者自行处理后续逻辑
               } else {
                   // 资源已用完，线程等待资源释放
                   thread.awaitResourceRelease(); // 阻塞并等待资源释放
               }
           } finally {
               lock.unlock(); // 无论是否成功获取锁，都需要解锁
           }
       }

public class ExampleThread extends Thread {
           private ResourcePool resourcePool;

public ExampleThread(ResourcePool resourcePool) {
               this.resourcePool = resourcePool;
           }

@Override
           public void run() {
               try {
                   // 请求资源
                   resourcePool.requestResources(this);
                   // 线程执行任务
                   // ...
                   // 释放资源
                   resourcePool.releaseResources(this);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   }
}
```
在这个例子中，`ResourcePool` 类代表了一个资源池，可以管理可用的资源。`ExampleThread` 类是一个线程实例，它请求资源、执行任务并最终释放资源。

在主线程运行时，可能会出现锁竞争（多个线程同时尝试获取同一个锁）和死锁等问题，具体取决于资源池的设计以及线程执行的具体逻辑。