容器 多線程訪問資源

一、ArrayBlockingQueue https://blog.csdn.net/qq_23359777/article/details/70146778

二、CopyOnWriteArrayList https://blog.csdn.net/hua631150873/article/details/51306021

 

信號量 <用於避免線程搶佔資源形成的阻塞>

假若有有三個取餐窗口能夠取餐，有五我的來吃飯，那麼有兩我的就必須處於等待狀態。知道前三我的有離開後續的人才能進行取餐。       // 代碼實例

public static void main() {
    ExecutorService service = Executors.newFixedThreadPool(3);
    final Semaphore semaphore = new Semaphore(3);
    for (int i = 0; i < 5; i++) {
        service.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    semaphore.acquire();
                    System.out.println("剩餘許可 = " + semaphore.availablePermits());
                    Thread.sleep(1000);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

循環柵欄 容許一組線程互相等待，知道達到某個公共屏障點。

/**
 * 循環柵欄 zhalan
 */
public static class CyclicBarrierTest {
    private static final int SIZE = 5;
    private static CyclicBarrier cyclicBarrier;

    public static void main(String[] args) {
        cyclicBarrier = new CyclicBarrier(SIZE, new Runnable() {
            @Override
            public void run() {
                System.out.println("--> 知足條件 <-- " + cyclicBarrier.getParties());
            }
        });
        for (int i = 0; i < 5; i++) {
            new Work().start();
        }
    }

    static class  Work extends Thread{
        @Override
        public void run() {
            super.run();
            System.out.println(Thread.currentThread().getName() + "等待 CyclicBarrier");
            try {
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName() + "繼續執行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread-3 等待 CyclicBarrier
Thread-2 等待 CyclicBarrier
Thread-1 等待 CyclicBarrier
Thread-4 等待 CyclicBarrier
Thread-5 等待 CyclicBarrier
--> 知足條件 <-- 5
Thread-4 繼續執行
Thread-2 繼續執行
Thread-1 繼續執行
Thread-3 繼續執行
Thread-5 繼續執行

閉鎖  <容許一個或多個線程一直等待，直到知足條件>

/**
 * 閉鎖
 */
public static class CountDownLatchTest {
    private static final int SIZE = 5;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(SIZE);
        for (int i = 0; i < 5; i++) {
            new Work(latch).start();
        }
        System.out.println("主線程等待");
        latch.await();
        System.out.println("主線程繼續執行");
    }

    static class  Work extends Thread{
        CountDownLatch latch;
        Work( CountDownLatch latch){
            this.latch = latch;
        }
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " 執行操做");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

主線程等待
Thread-4 執行操做
Thread-1 執行操做
Thread-3 執行操做
Thread-5 執行操做
Thread-2 執行操做
主線程繼續執行