Java中的CyclicBarrier、CountDownLatch和Semaphore的具体使用

import java.util.concurrent.CountDownLatch;
public class ServiceLoader {
    // 初始计数器为3，表示需要等待3个服务加载
    private static final CountDownLatch latch = new CountDownLatch(3);
    public static void main(String[] args) throws InterruptedException {
        // 启动服务加载线程
        new Thread(new Service("Service 1", latch)).start();
        new Thread(new Service("Service 2", latch)).start();
        new Thread(new Service("Service 3", latch)).start();
        // 主线程等待服务加载完成
        latch.await();
        System.out.println("所有服务已加载完成，服务可以开始接收请求...");
    }
    static class Service implements Runnable {
        private final String name;
        private final CountDownLatch latch;
        public Service(String name, CountDownLatch latch) {
            this.name = name;
            this.latch = latch;
        }
        @Override
        public void run() {
            try {
                // 模拟服务加载耗时操作
                Thread.sleep((long) (Math.random() * 1000));
                System.out.println(name + " 服务加载完成.");
                // 服务加载完成后，计数器减一
                latch.countDown();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.BrokenBarrierException;
public class DataProcessor {
    private static final int NUMBER_OF_THREADS = 3;
    private static CyclicBarrier barrier = new CyclicBarrier(NUMBER_OF_THREADS, 
        new Runnable() {
            @Override
            public void run() {
                // 当所有线程到达屏障点时执行
                System.out.println("所有计算完成，进行数据合并...");
            }
        });
    public static void main(String[] args) {
        for(int i = 0; i < NUMBER_OF_THREADS; i++) {
            new Thread(new Worker(i)).start();
        }
    }
    static class Worker implements Runnable {
        private int id;
        public Worker(int id) {
            this.id = id;
        }
        @Override
        public void run() {
            try {
                // 模拟数据处理
                System.out.println("线程 #" + id + " 正在处理数据...");
                Thread.sleep((long) (Math.random() * 1000));
                System.out.println("线程 #" + id + " 数据处理完成，等待其他线程...");
                // 等待其他线程都执行到这个点
                barrier.await();
                System.out.println("线程 #" + id + " 继续后续操作...");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.util.concurrent.Semaphore;
public class ResourcePool {
    private static final int MAX_AVAILABLE = 5;
    private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
    public Object getItem() throws InterruptedException {
        available.acquire();
        try {
            // 模拟获取资源的操作
            return getNextAvailableItem();
        } finally {
            // 保证在资源使用后一定会释放许可证
            available.release();
        }
    }
    // 此处省略了资源管理的其他逻辑...
    public static void main(String[] args) {
        final ResourcePool pool = new ResourcePool();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    Object item = pool.getItem();
                    // 模拟使用资源
                    System.out.println(Thread.currentThread().getName() + " 获取了资源");
                    Thread.sleep((long) (Math.random() * 1000));
                    // 假设这里是使用资源完成后的操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
    // 此处省略了getNextAvailableItem方法的实现，它应该负责分配资源
}