Java多线程同步控制问题：信号量、条件变量的使用示例

原创系统管理员 2024-11-26 17:15 3阅读 0赞

在Java中，我们可以使用`Semaphore`和`ConditionVariable`来实现多线程的同步控制。

1. 信号量（Semaphore）：

信号量是一种资源管理机制，它允许一个或多个线程访问特定数量的共享资源。

示例代码：

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

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

public void threadA() {
        try {
            permit.acquire();
            // 执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void threadB() {
        try {
            permit.acquire();
            // 执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

Thread tA = new Thread(example::threadA));
        Thread tB = new Thread(example::threadB));

tA.start();
        tB.start();

// 等待所有线程执行完毕
        try {
            tA.join();
            tB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

2. 条件变量（ConditionVariable）：

条件变量用于实现多线程的同步，只有满足特定条件时，线程才能进入等待状态。

示例代码：

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

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

public void threadA() {
        try {
            lock.lock();
            // 满足条件，进入等待状态
            condition.await();
            // 执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

public void threadB() {
        try {
            lock.lock();
            // 提供条件
            condition.signalAll(); // 信号所有等待线程
            // 执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

Thread tA = new Thread(example::threadA));
        Thread tB = new Thread(example::threadB));

tA.start();
        tB.start();

// 等待所有线程执行完毕
        try {
            tA.join();
            tB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上示例展示了如何使用`Semaphore`和`ConditionVariable`来实现多线程的同步控制。