Java多线程同步：互斥锁与条件变量的实战案例

原创待我称王封你为后i 2024-12-03 10:39 15阅读 0赞

在Java多线程编程中，互斥锁和条件变量是两种常用的同步机制。下面我们将通过一个实战案例来理解它们的应用。

**实战案例：生产者消费者问题**

假设我们有两个角色：生产者（Producer）和消费者（Consumer）。生产者负责生成产品，而消费者负责消费这些产品。但是由于资源有限，我们需要使用互斥锁来保护资源。

1. 生产者类（Producer.java）：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Producer {
    private Lock lock = new ReentrantLock();

public void produce(int products) {
        for (int i = 0; i < products; i++) {
            try {
                // 在生产产品时获取锁
                lock.acquire();

// 生产产品，这里可以是打印、数据库操作等
                System.out.println("Product produced: " + i);

} catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 无论是否成功生产，都释放锁
                lock.release();
            }
        }
    }
}
```

2. 消费者类（Consumer.java）：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Consumer {
    private Lock lock = new ReentrantLock();

public void consume(int products) {
        for (int i = 0; i < products; i++) {
            try {
                // 在消费产品时获取锁
                lock.acquire();

// 消费产品，这里可以是打印、数据库操作等
                System.out.println("Product consumed: " + i);

} catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 无论是否成功消费，都释放锁
                lock.release();
            }
        }
    }
}
```

3. 主程序（Main.java）：

```java
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        // 创建生产者和消费者线程池
        Executors producerExecutor = Executors.newSingleThreadExecutor();
        Executors consumerExecutor = Executors.newSingleThreadExecutor();

// 生产者线程
        producerExecutor.execute(new Producer());

// 消费者线程
        consumerExecutor.execute(new Consumer());

// 线程池关闭，所有任务完成后退出程序
        producerExecutor.shutdown();
        consumerExecutor.shutdown();
        try {
            producerExecutor.awaitTermination(10, TimeUnit.SECONDS);
            consumerExecutor.awaitTermination(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

通过上述示例，我们使用互斥锁来保护资源（生产者和消费者），并利用条件变量来实现生产者等待产品生成，以及消费者等待产品消费的逻辑。