Java中并发编程，如信号量、条件变量的例子

原创柔光的暖阳◎ 2024-12-07 08:06 17阅读 0赞

在Java中，我们可以使用java.util.concurrent包中的Semaphore（信号量）和ConditionVariable（条件变量）进行并发编程。

1. 信号量示例：

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

public class SemaphoreExample {
    private Semaphore permit = new Semaphore(1); // 初始化为1个许可

public void acquire() {
        try {
            permit.acquire(); // 获取许可
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void release() {
        try {
            permit.release(); // 释放许可
        } catch (RuntimeException e) {
            e.printStackTrace();
        }
    }

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

new Thread(() -> {
            semaphoreExample.acquire();
            System.out.println("Thread 1 acquired.");
            semaphoreExample.release();
        })).start();

new Thread(() -> {
            semaphoreExample.acquire();
            System.out.println("Thread 2 acquired.");
            // 这里可以模拟一些耗时操作
            try {
                Thread.sleep(500); // 模拟耗时，实际上不需要
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            semaphoreExample.release();
        })).start();

// 等待所有线程执行完毕
        try {
            new Thread(() -> {
                // 这里是主线程，用于处理其他情况
                System.out.println("Main thread waiting...");
            })).start();

// 线程睡眠时间，可以调整等待的时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在上述示例中，我们创建了一个Semaphore对象，初始化为1个许可。两个线程交替调用acquire()和release()方法。

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 notEmpty = lock.newCondition();

private int count = 0;

public void put() {
        try {
            lock.lock(); // 获取锁

if (count < 5) { // 先检查容量，防止溢出
                System.out.println("Put, count = " + count);
                count++;
            }

notEmpty.signal(); // 设置信号，表示数据已更新

} catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }

public void take() throws InterruptedException {
        try {
            lock.lock(); // 获取锁

while (count == 0) { // 等待数据被添加
                notEmpty.await(); // 设置等待条件，直到信号发出
            }

System.out.println("Take, count = " + count);
            count--;

} catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }

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

Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Producer put " + i);
                example.put(); // 添加数据
            }
        }));

Thread consumer = new Thread(() -> {
            while (!example.take())) { // 从队列中获取数据
                System.out.println("Consumer wait...");
            }

System.out.println("Consumer take finished.");
        }));

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

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

在上述示例中，我们创建了一个带条件变量的锁（Lock）对象。生产者（Producer）线程负责往队列（ConditionVariable）添加数据，而消费者（Consumer）线程则从队列获取数据。

通过调用put()和take()方法，我们可以控制数据的进出流程。