Java并发编程：CountDownLatch和Semaphore使用实例

原创蔚落 2024-12-08 15:57 15阅读 0赞

在Java并发编程中，`CountDownLatch`和`Semaphore`是两种常用的同步工具。它们各自有不同的特性，适用于不同的场景。

1. CountDownLatch

- 作用：当一个或多个线程完成某个操作后，会调用`countDown()`方法来减少CountDownLatch的计数器值。

- 使用示例：

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

public class CountDownLatchExample {
    private final CountDownLatch countDownLatch = new CountDownLatch(3);

public void await() throws InterruptedException {
        countDownLatch.await();
        System.out.println("All threads completed.");
    }

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

// 创建三个线程，每个线程执行await()方法
        Thread thread1 = new Thread(() -> example.await()));
        Thread thread2 = new Thread(() -> example.await()));
        Thread thread3 = new Thread(() -> example.await()));

// 启动线程
        thread1.start();
        thread2.start();
        thread3.start();

// 等待所有线程完成
        example.countDownLatch.await();
    }
}
```

2. Semaphore

- 作用：Semaphore是一种多路信号，它允许一个或多个线程同时访问一个共享资源。

- 使用示例：

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

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

public void acquire() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Acquired semaphore.");
    }

public void release() {
        semaphore.release();
        System.out.println("Released semaphore.");
    }

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

// 创建两个线程，每个线程执行acquire()方法
        Thread thread1 = new Thread(() -> example.acquire()));
        Thread thread2 = new Thread(() -> example.acquire()));

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程完成释放操作
        try {
            example.semaphore.release(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上两种工具在并发编程中经常被使用，根据实际需求选择合适的方式进行同步。