Java并发工具：CountDownLatch和Semaphore的用法示例

原创深藏阁楼爱情的钟 2024-09-06 01:09 76阅读 0赞

在Java中，CountDownLatch和Semaphore都是用于管理线程同步的工具。下面我们将通过一些实例来演示它们的使用。

1. **CountDownLatch**：
CountDownLatch主要用于一个或多个线程等待其他线程完成特定操作后释放计数器。

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

public class CountDownLatchExample {
    private CountDownLatch signal = new CountDownLatch(1);

public void workerThread() throws InterruptedException {
        System.out.println("Worker thread started");
        signal.await(); // Wait for the signal to decrement below 0
        System.out.println("Worker thread finished");
    }

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

Thread workerThread = new Thread(example::workerThread);
        workerThread.start();

// This thread will wait until the worker thread finishes
        Thread signalSender = new Thread(() -> {
            System.out.println("Signal sent to worker thread");
            signal.countDown(); // Decrement the count of the signal
        }));
        signalSender.start();

signalSender.join(); // Wait for the signal sender to finish

if (signal.getCount() == 0) { // If the signal is empty, all worker threads must have finished
            System.out.println("All worker threads finished successfully");
        } else {
            System.out.println("Worker thread(s) still running");
        }
    }
}
```

2. **Semaphore**：
Semaphore主要用于线程间的互斥，它允许同时的访问量有一个上限。

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

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(1); // Initialize the semaphore with capacity 1

public void workerThread() throws InterruptedException {
        System.out.println("Worker thread started");
        semaphore.acquire(); // Acquire a permit from the semaphore
        System.out.println("Worker thread finished");
    }

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

Thread workerThread = new Thread(example::workerThread);
        workerThread.start();

// This thread will wait until the worker thread finishes and releases the semaphore permit
        Thread signalSender = new Thread(() -> {
            System.out.println("Signal sent to worker thread");
            if (semaphore.tryAcquire()) { // Try to acquire a permit from the semaphore. If successful, the tryAcquire() method returns true.
                System.out.println("Semaphore permit acquired by worker thread");
                } else {
                    System.out.println("Semaphore permit already acquired by another worker thread");
                }
        }));
        signalSender.start();

signalSender.join(); // Wait for the signal sender to finish

if (semaphore.getQuota() == 0) { // If the semaphore permit quota is empty, all worker threads must have finished and released their permits
            System.out.println("All worker threads finished successfully");
        } else {
            System.out.println("Worker thread(s) still running");
        }
    }
}
```

在这个例子中，CountDownLatch用于等待所有workerThread完成，Semaphore则用于控制同时执行的线程数量。