Java并发编程：线程同步问题案例

原创冷不防 2024-10-07 13:03 88阅读 0赞

在Java并发编程中，线程同步问题是经常遇到的。这里以一个典型的生产者消费者问题为例，阐述线程同步的问题。

1. 问题描述：
   - 生产者（Producer）向共享队列（Queue）添加元素。
   - 消费者（Consumer）从队列获取元素并处理。

2. 问题案例分析：
   - **无同步**：最简单的实现，没有使用任何同步机制。这样的代码可能会导致数据竞争和线程挂起等问题。
   ```java
   class SimpleQueue {
       List<String> queue = new ArrayList<>();
       
       // 生产者添加元素
       public synchronized void producer(String item) {
           queue.add(item);
           notifyAll(); // 通知等待的消费者
       }
       
       // 消费者获取并处理元素
       public synchronized String consumer() {
           if (queue.isEmpty()) { // 空队，阻塞消费
               wait();
               return "Queue empty!";
           } else {
               String item = queue.remove(0); // 取出第一个元素
               notifyAll(); // 通知等待的生产者
               return item;
           }
       }
   }
   ```
   
   - **使用锁（Lock）**：为了防止数据竞争，我们可以使用`java.util.concurrent.locks.Lock`。这里以ReentrantLock为例。
   ```java
   import java.util.concurrent.locks.ReentrantLock;

class QueueWithLock {
       private List<String> queue = new ArrayList<>();
       
       // 生产者添加元素
       public void producer(String item) {
           lock.acquire(); // 获取锁
           try {
               queue.add(item);
           } finally {
               lock.release(); // 释放锁
           }
       }
       
       // 消费者获取并处理元素
       public String consumer() {
           lock.acquire(); // 获取锁
           try {
               if (queue.isEmpty()) { // 空队，阻塞消费
                   lock.lockInterruptibly(); // 使用中断方式释放锁
                   return "Queue empty!";
               } else {
                   String item = queue.remove(0); // 取出第一个元素
                   lock.unlock(); // 释放锁
                   return item;
               }
           } catch (InterruptedException e) { // 处理中断异常
               lock.unlockInterruptibly(); // 使用中断方式释放锁
               e.printStackTrace();
           } finally {
               lock.release(); // 无论是否使用中断，都必须释放锁
           }
       }
   }
   ```
   
   - **使用Semaphore（信号量）**：信号量是一种线程同步机制，用于控制对共享资源的访问。这里以CountDownLatch为例。
   ```java
   import java.util.concurrent.CountDownLatch;
   
   class QueueWithSemaphore {
       private List<String> queue = new ArrayList<>();
       
       // 生产者添加元素
       public void producer(String item) throws InterruptedException {
           semaphore.acquire(); // 获取信号量，允许一次消费操作
           try {
               queue.add(item);
           } finally {
               semaphore.release(); // 释放信号量，禁止后续消费操作
           }
       }
       
       // 消费者获取并处理元素
       public String consumer() throws InterruptedException {
           semaphore.acquire(); // 获取信号量，允许一次消费操作
           try {
               if (queue.isEmpty()) { // 空队，阻塞消费
                   semaphore.releaseInterruptibly(); // 使用中断方式释放信号量并返回结果
                   return "Queue empty!";
               } else {
                   String item = queue.remove(0); // 取出第一个元素
                   semaphore.release(); // 释放信号量，禁止后续消费操作
                   return item;
               }
           } catch (InterruptedException e) { // 处理中断异常
               semaphore.releaseInterruptibly(); // 使用中断方式释放信号量并返回结果
               e.printStackTrace();
           } finally {
               semaphore.release(); // 无论是否使用中断，都必须释放信号量
           }
       }
   }
   ```
   
   - **总结**：
   线程同步是Java并发编程中的一大难题。通过上述案例，我们可以看到不同线程同步方式的优缺点。在实际应用中，应根据具体场景选择合适的同步机制。