Java并发编程实战：锁、信号量与条件变量应用示例

原创谁借莪１个温暖的怀抱￠ 2024-09-29 08:42 96阅读 0赞

在Java并发编程中，锁（Lock）、信号量（Semaphore）和条件变量（Condition Variable）是重要的工具。这里我将为你展示它们的应用示例。

1. 锁（Lock）
   - 使用场景：当一个共享资源需要多线程同时访问时，就需要使用锁来控制并发访问。
   
   示例：
   ```java
   class Counter {
       private int count = 0;
       
       // 加锁
       synchronized void increment() {
           count++;
       }
       
       // 解锁
       synchronized void decrement() {
           count--;
       }
       
       public int getCount() {
           return count;
       }
   }
   ```
2. 信号量（Semaphore）
   - 使用场景：当一个共享资源的容量有限时，可以使用信号量来控制并发访问。
   
   示例：
   ```java
   class CarPark {
       private int available停车位 = 10; // 停车位总数
       
       // 信号量增加表示有停车位可供使用
       Semaphore carparkAvailable = new Semaphore(available停车位);
       
       // 信号量减少表示有车辆停入，停车位变少
       Semaphore carparkOccupied = new Semaphore(0); // 全部车位已被占用

// 停车位检查接口
       public interface CarParkChecker {
           boolean isAvailable(Carpark park, String plateNum));
           boolean isOccupied(Carpark park, String plateNum));
       }

// 创建停车场检查器
       private CarParkChecker checker = new CarParkCheckerImpl();

// 租车服务，返回是否成功以及当前停车位状态
       public boolean rentCar(Carpark park, String plateNum)) {
           // 车辆检查：如果车位已满，则不允许租车。
           if (!checker.isAvailable(park, plateNum))) {
               System.out.println("Sorry, the car is not available at this moment.");
               return false;
           }

// 租车操作，更新信号量表示有车辆停入
           park.carparkOccupied.increment();
           System.out.println("The car has been rented successfully. Please drive carefully.");
           return true;
       }
   }
   ```
3. 条件变量（Condition Variable）
   - 使用场景：当一个线程需要等待某个条件满足时，可以使用条件变量来实现。
   
   示例：
   ```java
   class Producer extends Thread {
       private CarPark park;
       
       // 初始化公园和条件变量
       public Producer(Carpark park) {
           this.park = park;
           start();
       }

@Override
       public void run() {
           // 生成产品并放入停车场
           for (int i = 0; i < 10; i++) {
               String plateNum = "PLT-" + String.format("%03d", i));
               if (!park.checker.isAvailable(park, plateNum))) {
                   park.checker.isAvailable(park, plateNum)); // 将车位标记为可用
                   System.out.println("Product PLT-" + String.format("%03d", i)) + " has been successfully produced and parked.");
                   park.carparkOccupied.decrement(); // 信号量减少表示有车辆停出，停车位变多
               }
           }
       }
   }

class Consumer extends Thread {
       private CarPark park;
       
       // 初始化公园和条件变量
       public Consumer(Carpark park) {
           this.park = park;
           start();
       }

@Override
       public void run() {
           while (true) {
               if (park.checker.isAvailable(park, "PLT-001"))) { // 如果有可用的车位
                   String plateNum = "PLT-001"; // 选择其中的一个作为租车对象
                   park.rentCar(park, plateNum)); // 租车操作，将车辆移出停车场

System.out.println("The car PLT-001 has been successfully rented and driven away.");
                   break; // 跳出循环，不再尝试租赁其他车位
               }
               try {
                   Thread.sleep(2000); // 每隔2秒检查一次车位状态
               } catch (InterruptedException e) {
                   System.out.println("Error occurred while checking available parking spots: " + e.getMessage());
                   Thread.currentThread().interrupt(); // 强制中断线程
               }
           }
       }
   }

public class CarParkDemo {
       public static void main(String[] args) {
           CarPark park = new CarPark(CarParkType.ParkingLot)); // 初始化一个停车场实例

Producer producer1 = new Producer(park); // 创建第一个生产者
           Consumer consumer1 = new Consumer(park); // 创建第一个消费者，它会消费producer1产出的产品

Thread producer1Thread = new Thread(producer1); // 创建并启动生产者线程
           Thread consumer1Thread = new Thread(consumer1); // 创建并启动消费者线程

producer1Thread.start(); // 启动生产者线程
           consumer1Thread.start(); // 启动消费者线程

try {
               producer1Thread.join(); // 等待生产者线程结束，如果在此期间线程被中断，则会抛出InterruptedException异常
               consumer1Thread.join(); // 等待消费者线程结束，如果在此期间线程被中断，则会抛出InterruptedException异常
           } catch (InterruptedException e) {
               System.out.println("Error occurred while joining threads: " + e.getMessage());
           }
       }
   }
}
```
这个示例中，我们创建了一个停车场（CarPark）类，它包括了生产者（Producer）和消费者（Consumer）的实现。

生产者会生成产品并将其放入停车场，消费者则会消费这些产品。

整个程序运行后，生产者和消费者线程同时启动，各自完成任务。