Java多线程同步问题探讨：信号量与条件变量示例

原创比眉伴天荒 2024-10-25 15:24 72阅读 0赞

在Java多线程编程中，线程的同步主要通过两种机制来实现：信号量（Semaphore）和条件变量（Condition Variable）。

1. 信号量示例：
   假设有一个资源池，资源数量有限，每个线程进来都需要一个资源。此时可以使用信号量来控制资源的数量。
   ```java
   // 定义信号量
   Semaphore resourcePool = new Semaphore(3);

// 线程1获取资源
   Thread t1 = new Thread(() -> {
       try {
           resourcePool.acquire();  // 获取资源
           System.out.println("Thread 1 uses resource");
           resourcePool.release();    // 释放资源
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }));

// 线程2获取资源
   Thread t2 = new Thread(() -> {
       try {
           resourcePool.acquire();  // 获取资源
           System.out.println("Thread 2 uses resource");
           resourcePool.release();    // 释放资源
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }));

t1.start();
   t2.start();
   ```

2. 条件变量示例：
   条件变量通常与锁（如synchronized关键字）结合使用，用于控制线程的执行。
   ```java
   // 假设有一个生产者和消费者线程
   class Product {
       private int id;
       public Product(int id) { this.id = id; }
       // 省略产品获取和处理的方法
   }

class Consumer {
       private Product product;
       public Consumer(Product product) { this.product = product; }
       // 省略消费者获取和处理产品的方法
       public void consume() {
           // 条件变量用于等待特定条件发生时才执行操作
           synchronized (producer.lock) {
               if (product.id == 0) {    // 如果产品为空，等待条件
                   producer.wait();
                   }
               else {          // 如果产品不为空，直接消费
                   System.out.println("Consumer consumes product with ID: " + product.id);
                   consumeProduct(product);  // 调用消费者处理产品的方法
                   break;
               }
           }
       }

// 省略消费者处理产品的方法
   }

class Producer {
       private Product product;
       private Object lock;  // 锁，用于同步对产品进行操作的线程

public Producer(Product product) { this.product = product; this.lock = new Object(); }
       // 省略生产者获取和处理产品的方法

public synchronized void produce() {
           if (product.id == 0) {    // 如果产品为空，创建一个新产品
                   System.out.println("Producer produces a new product with ID: 0");
                   product = new Product(0);
               }
               else {          // 如果产品不为空，更新产品的ID
                   System.out.println("Producer updates the product with ID: " + product.id);
                   product.id++;
               }

// 生产完成后通知消费者等待产品
               notifyAll();
       }
   }

public class MultiThreadExample {
       public static void main(String[] args) {
           Product prod = new Product(1);  // 创建一个初始ID为1的产品

Producer producer = new Producer(prod);  // 创建一个生产者，它将处理这个产品
           Consumer consumer = new Consumer(prod);  // 创建一个消费者，它将消费来自生产者的产品

// 启动线程
           Thread producerThread = new Thread(producer::produce));
           Thread consumerThread = new Thread(consumer::consume));

producerThread.start();
           consumerThread.start();

try {
               producerThread.join();  // 等待生产者线程结束
               consumerThread.join();   // 等待消费者线程结束
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}
```

以上代码示例中，`Product`、`Producer`和`Consumer`分别代表产品、生产者和消费者。通过创建这些类的实例并启动相关的线程来实现多线程同步控制。