public class CountDownLatchDemo {
    // 定義前置任務(wù)線程
    static class PreTaskThread implements Runnable {

        private String task;
        private CountDownLatch countDownLatch;

        public PreTaskThread(String task, CountDownLatch countDownLatch) {
            this.task = task;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                Random random = new Random();
                Thread.sleep(random.nextInt(1000));
                System.out.println(task + " - 任務(wù)完成");
                countDownLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 假設(shè)有三個模塊需要加載
        CountDownLatch countDownLatch = new CountDownLatch(3);

        // 主任務(wù)
        new Thread(() -> {
            try {
                System.out.println("等待數(shù)據(jù)加載...");
                System.out.println(String.format("還有%d個前置任務(wù)", countDownLatch.getCount()));
                countDownLatch.await();
                System.out.println("數(shù)據(jù)加載完成，正式開始游戲！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 前置任務(wù)
        new Thread(new PreTaskThread("加載地圖數(shù)據(jù)", countDownLatch)).start();
        new Thread(new PreTaskThread("加載人物模型", countDownLatch)).start();
        new Thread(new PreTaskThread("加載背景音樂", countDownLatch)).start();
    }
}

// 構(gòu)造方法：
public CountDownLatch(int count)

public void await() // 等待
public boolean await(long timeout, TimeUnit unit) // 超時等待
public void countDown() // count - 1
public long getCount() // 獲取當(dāng)前還有多少count

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

public CountDownLatch(int count) {
  if (count < 0) throw new IllegalArgumentException("count < 0");
  this.sync = new Sync(count);
}

public void countDown() {
    sync.releaseShared(1);
}

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) { //對計數(shù)器進(jìn)行減一操作
        doReleaseShared();//如果計數(shù)器為0，喚醒被await方法阻塞的所有線程
        return true;
    }
    return false;
}

protected boolean tryReleaseShared(int releases) {
    for (;;) {//死循環(huán)，如果CAS操作失敗就會不斷繼續(xù)嘗試。
        int c = getState();//獲取當(dāng)前計數(shù)器的值。
        if (c == 0)// 計數(shù)器為0時，就直接返回。
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))// 使用CAS方法對計數(shù)器進(jìn)行減1操作
            return nextc == 0;//如果操作成功，返回計數(shù)器是否為0
    }
}

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)//判斷計數(shù)器是否為0
        doAcquireSharedInterruptibly(arg);//如果不為0則阻塞當(dāng)前線程
}

protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

public class CyclicBarrierDemo {
    static class PreTaskThread implements Runnable {

        private String task;
        private CyclicBarrier cyclicBarrier;

        public PreTaskThread(String task, CyclicBarrier cyclicBarrier) {
            this.task = task;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            // 假設(shè)總共三個關(guān)卡
            for (int i = 1; i < 4; i++) {
                try {
                    Random random = new Random();
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(String.format("關(guān)卡%d的任務(wù)%s完成", i, task));
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
            System.out.println("本關(guān)卡所有前置任務(wù)完成，開始游戲...");
        });

        new Thread(new PreTaskThread("加載地圖數(shù)據(jù)", cyclicBarrier)).start();
        new Thread(new PreTaskThread("加載人物模型", cyclicBarrier)).start();
        new Thread(new PreTaskThread("加載背景音樂", cyclicBarrier)).start();
    }
}

public CyclicBarrier(int parties, Runnable barrierAction) {
  if (parties <= 0) throw new IllegalArgumentException();
  this.parties = parties;
  this.count = parties;
  this.barrierCommand = barrierAction;
}

public CyclicBarrier(int parties) {
  this(parties, null);
}

 public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }

public int await(long timeout, TimeUnit unit)
    throws InterruptedException,
           BrokenBarrierException,
           TimeoutException {
    return dowait(true, unit.toNanos(timeout));
}

private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {       
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            // 每次使用屏障都會生成一個實(shí)例
            final Generation g = generation;

            // 如果被破壞了就拋異常
            if (g.broken)
                throw new BrokenBarrierException();

            // 線程中斷檢測
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }

            // 剩余的等待線程數(shù)
            int index = --count;
            // 最后線程到達(dá)時 
            if (index == 0) {  // tripped
                // 標(biāo)記任務(wù)是否被執(zhí)行（就是傳進(jìn)入的runable參數(shù)）
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    // 執(zhí)行任務(wù)
                    if (command != null)
                        command.run();
                    ranAction = true;
                    // 完成后 進(jìn)行下一組 初始化 generation 初始化 count 并喚醒所有等待的線程 
                    nextGeneration();
                    return 0;
                } finally {
                    if (!ranAction)
                        breakBarrier();
                }
            }

            // index 不為0時 進(jìn)入自旋
            for (;;) {
                try {
                    // 先判斷超時 沒超時就繼續(xù)等著
                    if (!timed)
                        trip.await();
                        // 如果超出指定時間 調(diào)用 awaitNanos 超時了釋放鎖
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                        // 中斷異常捕獲
                } catch (InterruptedException ie) {
                    // 判斷是否被破壞
                    if (g == generation && ! g.broken) {
                        breakBarrier();
                        throw ie;
                    } else {
                        // 否則的話中斷當(dāng)前線程
                        Thread.currentThread().interrupt();
                    }
                }

                // 被破壞拋異常
                if (g.broken)
                    throw new BrokenBarrierException();

                // 正常調(diào)用 就返回 
                if (g != generation)
                    return index;

                // 超時了而被喚醒的情況 調(diào)用 breakBarrier()
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();   // break the current generation
        nextGeneration(); // start a new generation
    } finally {
        lock.unlock();
    }
}

public class SemaphoreDemo {

    private static Semaphore semaphore = new Semaphore(10);

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("歡迎 " + Thread.currentThread().getName() + " 來到停車場");
                    // 判斷是否允許停車
                    if (semaphore.availablePermits() == 0) {
                        System.out.println("車位不足，請耐心等待");
                    }
                    try {
                        // 嘗試獲取
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + " 進(jìn)入停車場");
                        Thread.sleep(new Random().nextInt(10000));// 模擬車輛在停車場停留的時間
                        System.out.println(Thread.currentThread().getName() + " 駛出停車場");
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, i + "號車");
            thread.start();
        }
    }
}

public class ExchangerDemo {

    public static void main(String[] args) throws InterruptedException {
        Exchanger<String> stringExchanger = new Exchanger<>();

        Thread studentA = new Thread(() -> {
            try {
                String dataA = "A同學(xué)收藏多年的大片";
                String dataB = stringExchanger.exchange(dataA);
                System.out.println("A同學(xué)得到了" + dataB);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("這個時候A同學(xué)是阻塞的，在等待B同學(xué)的大片");
        Thread.sleep(1000);

        Thread studentB = new Thread(() -> {
            try {
                String dataB = "B同學(xué)收藏多年的大片";
                String dataA = stringExchanger.exchange(dataB);
                System.out.println("B同學(xué)得到了" + dataA);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        studentA.start();
        studentB.start();
    }
}

public V exchange(V x, long timeout, TimeUnit unit)

public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger<String> stringExchanger = new Exchanger<>();
        Thread studentA = new Thread(() -> {
            String dataB = null;
            try {
                String dataA = "A同學(xué)收藏多年的大片";
                dataB = stringExchanger.exchange(dataA,5, TimeUnit.SECONDS);
                System.out.println("A同學(xué)得到了" + dataB);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                System.out.println("等待超時-TimeoutException");
            }
            System.out.println("A同學(xué)得到了："+dataB);
        });

        studentA.start();
    }
}