Java并发工具类：CountDownLatch，Semaphore用法实例

原创爱被打了一巴掌 2024-11-21 23:33 3阅读 0赞

CountDownLatch和Semaphore都是Java并发工具类，分别用于协调多个线程的执行顺序以及限制同时访问资源的数量。

以下是一些CountDownLatch和Semaphore的实际使用例子：

1. CountDownLatch：
```java
import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private CountDownLatch latch = new CountDownLatch(2);

public void workerThread() {
        try {
            latch.await();
            System.out.println("Worker thread completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

Thread workerThread1 = new Thread(example::workerThread);
        Thread workerThread2 = new Thread(example::workerThread);

workerThread1.start();
        workerThread2.start();

// 等待所有线程完成
        try {
            latch.countDown();
            latch.await();  // 这里可能不会被调用，因为CountDownLatch已经被countDown了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
在这个例子中，两个工作线程（workerThread1和workerThread2）会通过CountDownLatch同步等待。当所有线程都开始执行后，通过调用`latch.countDown();`将计数器减一，表示有一个工作线程已经完成并释放了锁。然后其他线程可以通过调用`latch.await();`来阻塞直到计数器变为0。

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

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

public void workerThread() {
        try {
            semaphore.acquire();  // 请求锁，如果当前线程已持有锁，则立即返回
            System.out.println("Worker thread completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();  // 释放锁
        }
    }

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

Thread workerThread1 = new Thread(example::workerThread);
        Thread workerThread2 = new Thread(example::workerThread);

workerThread1.start();
        workerThread2.start();

// 等待所有线程完成
        try {
            // 如果想要在所有线程都完成时释放锁，可以添加这个条件
            // semaphore.acquireWhile(!allThreadsDone));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
在这个例子中，每个工作线程（workerThread1和workerThread2）通过一个Semaphore来控制对共享资源的访问。当Semaphore计数为0时，其他线程将无法获取锁。当所有线程都完成执行后，通常会调用`semaphore.release();`来释放锁。