Java多线程并发控制：信号量与条件变量示例

原创红太狼 2024-11-26 16:09 0阅读 0赞

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

1. 信号量：
- 作用：限制同一时刻对共享资源的访问次数。
- 示例代码：
```java
import java.util.concurrent.Semaphore;

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

public void thread1() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Thread 1: Resource acquired.");
        // Do some work here
        Thread.sleep(2000);
        System.out.println("Thread 1: Resource released.");
        semaphore.release();
    }

public void thread2() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Thread 2: Resource acquired.");
        // Do some work here
        Thread.sleep(5000);
        System.out.println("Thread 2: Resource released.");
        semaphore.release();
    }

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

thread1.start();
        thread2.start();

// 等待所有线程完成
        thread1.join();
        thread2.join();
    }
}
```
在这个示例中，我们使用了一个`Semaphore`来控制两个线程对资源的访问。当资源数量为0时，后续线程会等待。

2. 条件变量：
- 作用：当满足特定条件时，线程可以被唤醒并执行相应的操作。
- 示例代码：
```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 condition = lock.newCondition();

public void thread1() {
        lock.lock();
        try {
            System.out.println("Thread 1: Entering critical section.");
            // 进行一些工作
            if (/*满足特定条件*/)) {
                System.out.println("Thread 1:满足条件，唤醒thread2.");
                condition.signalAll(); // 使用signalAll()唤醒所有等待的线程
            }
            System.out.println("Thread 1: Exiting critical section.");
        } finally {
            lock.unlock();
        }
    }

public void thread2() {
        try {
            lock.lock();
            condition.await(5000, TimeUnit.MILLISECONDS)); // 在5秒后被唤醒

System.out.println("Thread 2: Awaiting signal from thread1.");
            // 进行一些工作
            System.out.println("Thread 2: Received signal from thread1.");
            System.out.println("Thread 2: Exiting critical section.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

Thread thread1 = new Thread(example::thread1));
        Thread thread2 = new Thread(example::thread2));

thread1.start();
        thread2.start();

// 等待所有线程完成
        thread1.join();
        thread2.join();
    }
}
```
在这个示例中，`conditionVariableExample`类有一个锁（Lock）和一个条件变量（Condition）。当满足特定条件时，线程会调用`condition.signalAll()`来唤醒等待的所有线程。

在`thread1`和`thread2`中，分别代表了两个具有特定条件的线程。