并发编程：Java的CountDownLatch和Semaphore示例

原创川长思鸟来 2024-10-06 07:45 54阅读 0赞

在多线程编程中，我们经常需要管理共享资源或协调不同线程的执行。Java提供了`CountDownLatch`和`Semaphore`两个关键工具。

1. CountDownLatch

CountDownLatch是一个同步原语，它有一个可以被读取的计数器。当一个线程调用wait()方法时，它的状态将变为等待，且会释放已获得的锁。相反，调用countDown()方法的线程需要减少计数器的值。

示例代码：

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

public class CountDownLatchExample {
    private CountDownLatch countDownLatch;

public CountDownLatchExample(int initialCount) {
        countDownLatch = new CountDownLatch(initialCount);
    }

public void signalAll() {
        countDownLatch.countDown();
    }

public void waitTillSignaled(int numToSignal) {
        try {
            countDownLatch.await(numToSignal, TimeUnit.SECONDS));
            System.out.println("Received signal from " + numToSignal + " threads.");
        } catch (InterruptedException e) {
            System.out.println("Wait interrupted by signal:");
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        CountDownLatchExample example = new CountDownLatchExample(3);
        // 创建线程并等待信号
        Thread thread1 = new Thread(() -> example.signalAll()));
        Thread thread2 = new Thread(() -> example.waitTillSignaled(2)));
        Thread thread3 = new Thread(() -> example.waitTillSignaled(1)));

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

// 等待所有线程完成
        try {
            thread1.join();
            thread2.join();
            thread3.join();
            System.out.println("All threads completed.");
        } catch (InterruptedException e) {
            System.out.println("Join interrupted:");
            e.printStackTrace();
        }
    }
}
```

在这个示例中，我们创建了一个`CountDownLatchExample`类，它有一个用于计数的`CountDownLatch`。然后，我们创建了三个线程：一个调用`signalAll()`来减少计数器，另外两个分别调用`waitTillSignaled()`并传入不同的数字以等待信号。

当所有操作完成后，你会看到一条消息表示所有线程已完成。