Java并发工具：CountDownLatch，CyclicBarrier和Semaphore实例

原创约定不等于承诺〃 2024-10-08 03:48 85阅读 0赞

在Java中，CountDownLatch、CyclicBarrier和Semaphore是常用的并发控制工具。下面我将分别给出这些工具的实例。

1. CountDownLatch

CountDownLatch用于在一个线程等待另一个线程完成某些操作后释放资源。以下是一个简单的例子：

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

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

public void doSomething() throws InterruptedException {
        System.out.println("Starting task...");
        // 任务执行时间
        Thread.sleep(5000);
        signal.countDown();
        System.out.println("Task completed.");
    }

public static void main(String[] args) {
        CounterExample example = new CounterExample();
        new Thread(() -> example.doSomething())).start();

try {
            // 等待任务完成
            example.signal.await(5, TimeUnit.SECONDS));
            System.out.println("All tasks finished successfully.");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Main thread interrupted.");
        }
    }
}
```

2. CyclicBarrier

CyclicBarrier用于一组线程等待一个特定的屏障到达后，所有的线程都一起执行下一步。以下是一个简单的例子：

```java
import java.util.concurrent.CyclicBarrier;

public class BarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(2, "Task completed"));

public void doSomething() throws Exception {
        System.out.println("Starting task...");
        barrier.await();
        System.out.println("Task completed.");
    }

public static void main(String[] args) {
        BarrierExample example = new BarrierExample();
        new Thread(() -> example.doSomething())).start();

try {
            // 等待任务完成
            example.barrier.await(5, TimeUnit.SECONDS));
            System.out.println("All tasks finished successfully.");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Main thread interrupted.");
        }
    }
}
```

3. Semaphore

Semaphore是一种独占型资源，只能被一个进程访问。它的计数由系统管理，初始值为0或1。

以下是一个使用Semaphore的简单例子：

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

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

public void doSomething() throws InterruptedException {
        System.out.println("Starting task...");
        // 请求信号量，如果资源不足将阻塞
        semaphore.acquire();
        semaphore.release();  // 释放信号量，其他线程可以使用这个资源
        System.out.println("Task completed.");
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        new Thread(() -> example.doSomething())).start();

try {
            // 等待任务完成
            example.semaphore.acquire(5, TimeUnit.SECONDS));
            System.out.println("All tasks finished successfully.");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Main thread interrupted.");
        }
    }
}
```

以上就是CountDownLatch、CyclicBarrier和Semaphore在Java中的简单实例。