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

原创叁歲伎倆 2024-11-28 02:00 49阅读 0赞

在Java编程中，CountDownLatch和Semaphore是两种常用的并发控制工具。它们主要用来协调多个线程或者任务的执行。

1. CountDownLatch

CountDownLatch最初设计用于一个等待其他线程完成特定操作的线程。

使用示例：

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

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

public void task1() throws InterruptedException {
        System.out.println("Task 1 started.");
        latch.countDown(); // Complete the task and signal to other tasks
        System.out.println("Task 1 completed.");
    }

public void task2() throws InterruptedException {
        System.out.println("Task 2 started.");
        // Since task2 knows task1 is already finished, it can start its task directly.
        latch.await(5, TimeUnit.SECONDS)); // Wait for the signal from other tasks
        System.out.println("Task 2 completed.");
    }

public static void main(String[] args) {
        CountDownLatchExample example = new CountDownLatchExample();
        Thread thread1 = new Thread(example::task1);
        Thread thread2 = new Thread(example::task2);

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

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

2. Semaphore

Semaphore是一种同步工具，它最初用于控制同一资源访问的线程数量。

使用示例：

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

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(2); // Set the maximum number of permits to 2

public void task1() throws InterruptedException {
        System.out.println("Task 1 started.");
        semaphore.acquire(); // Acquire a permit. If not available, it will wait until one becomes available.
        // Since there are only two permits (set in Semaphore constructor), task2 can't start yet.
        if (!semaphore.tryAcquire(5, TimeUnit.SECONDS)))) {
            System.out.println("Task 1 couldn't acquire permit after waiting.");
            semaphore.release(); // Return the permit back to the pool so it can be reused.
            return;
        }
        // Now that task1 has successfully acquired a permit and performed its task, it releases the permit back to the semaphore's pool.
        System.out.println("Task 1 completed. Released permit.");
        semaphore.release();
    }

public void task2() throws InterruptedException {
        System.out.println("Task 2 started.");
        // Since task2 already knows that task1 has finished and released its permit, it can directly start its task without waiting for the permit to become available again.
        System.out.println("Task 2 completed.");
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        Thread thread1 = new Thread(example::task1);
        Thread thread2 = new Thread(example::task2);

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

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上两个示例展示了如何在Java并发编程中使用CountDownLatch和Semaphore工具。