Java并发编程中的线程安全问题：条件变量、信号量使用示例

原创 Love The Way You Lie 2024-09-26 17:57 36阅读 0赞

在Java并发编程中，条件变量和信号量是两种常用的同步工具，主要用于控制多线程对共享资源的访问。

1. 条件变量（Condition Variable）：

- 使用场景：当一个操作完成或者满足特定条件时，可以使用条件变量通知其他线程。

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

public class ConditionVariableExample {
    private Lock lock = new ReentrantLock();
    private Condition ready = lock.newCondition();

// 生产者方法
    public void produce() throws InterruptedException {
        lock.lock();
        try {
            while (!ready.await(10, TimeUnit.MILLISECONDS)))) {
                // 任务生产
                System.out.println("Producer produces...");
                Thread.sleep(500); // 模拟耗时操作
            }
        } finally {
            lock.unlock();
        }
    }

// 消费者方法
    public void consume() throws InterruptedException {
        lock.lock();
        try {
            while (!ready.signal())) {
                System.out.println("Consumer waits...");
                Thread.sleep(500);
            }
        } finally {
            lock.unlock();
        }
    }

public static void main(String[] args) {
        ConditionVariableExample example = new ConditionVariableExample();

Thread producer = new Thread(example::produce));
        Thread consumer = new Thread(example::consume));

producer.start();
        consumer.start();

// 等待两个线程全部执行完毕
        producer.join();
        consumer.join();
    }
}
```

2. 信号量（Semaphore）：

- 使用场景：当一个资源有限，且多个线程可能需要同时访问这个资源时，可以使用信号量来控制并发数量。

```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(1);

public void producer() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Producer produces...");
        Thread.sleep(500); // 模拟耗时操作
        semaphore.release();
    }

public void consumer() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Consumer waits...");
        Thread.sleep(500);
        semaphore.release();
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();

Thread producer = new Thread(example::producer));
        Thread consumer = new Thread(example::consumer));

producer.start();
        consumer.start();

// 等待两个线程全部执行完毕
        producer.join();
        consumer.join();
    }
}
```

以上示例展示了如何使用条件变量和信号量来实现Java并发编程中的线程安全。