import java.util.concurrent.CountDownLatch;
public class ServiceLoader {
    // 初始計數(shù)器為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 + " 服務加載完成.");
                // 服務加載完成后，計數(shù)器減一
                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() {
                // 當所有線程到達屏障點時執(zhí)行
                System.out.println("所有計算完成，進行數(shù)據(jù)合并...");
            }
        });
    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 {
                // 模擬數(shù)據(jù)處理
                System.out.println("線程 #" + id + " 正在處理數(shù)據(jù)...");
                Thread.sleep((long) (Math.random() * 1000));
                System.out.println("線程 #" + id + " 數(shù)據(jù)處理完成，等待其他線程...");
                // 等待其他線程都執(zhí)行到這個點
                barrier.await();
                System.out.println("線程 #" + id + " 繼續(xù)后續(xù)操作...");
            } 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方法的實現(xiàn)，它應該負責分配資源
}