public class MySemaphore {
    public static void main(String[] args) {
        // 使用线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        // 只允许3个线程同时访问
        final Semaphore semp = new Semaphore(3);
        
        // 模拟4个客户端访问
        for (int index = 0; index < 4; index++) {
            
            Runnable run = new Runnable() {
                public void run() {
                    try {
                        // 获取许可
                        semp.acquire();
                        
                        System.out.println("线程"+ Thread.currentThread().getName() + "获得许可：");
                        
                        // 模拟耗时的任务
                        for (int i = 0; i < 999999; i++);
                        
                        // 释放许可
                        semp.release();
                        
                        System.out.println("线程"+ Thread.currentThread().getName() + "释放许可：");
                        System.out.println("当前允许进入的任务个数："+ semp.availablePermits());
                    
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            
            exec.execute(run);
        }
        // 关闭线程池
        exec.shutdown();
    }
}

线程pool-1-thread-1获得许可：
线程pool-1-thread-2获得许可：
线程pool-1-thread-2释放许可： 
当前允许进入的任务个数：2       //总共允许3个许可, 获取两个许可, 释放一个许可, 剩余2个许可
线程pool-1-thread-1释放许可：
当前允许进入的任务个数：2      //释放一个许可, 应该打印出1, 可以看出, Semaphore并不保证线程安全 
线程pool-1-thread-3获得许可：
线程pool-1-thread-3释放许可：
当前允许进入的任务个数：2
线程pool-1-thread-4获得许可：
线程pool-1-thread-4释放许可：
当前允许进入的任务个数：3

public class MyCyclicBarrier {
    public static void main(String[] args) {   
        //创建CyclicBarrier对象， 并设置执行完一组5个线程的并发任务后，再执行MainTask任务  
        CyclicBarrier cb = new CyclicBarrier(5, new MainTask());  
        
        new SubTask("A", cb).start();   
        new SubTask("B", cb).start();   
        new SubTask("C", cb).start();   
        new SubTask("D", cb).start();   
        new SubTask("E", cb).start();  
}   
}   

/** 最后执行的任务 */
class MainTask implements Runnable {
    public void run() {
        System.out.println("......终于要执行最后的任务了......");
    }
}

/** 一组并发任务 */
class SubTask extends Thread {
    private String name;
    private CyclicBarrier cb;

    SubTask(String name, CyclicBarrier cb) {
        this.name = name;
        this.cb = cb;
    }

    public void run() {
        System.out.println("[并发任务" + name + "]  开始执行");
        
        for (int i = 0; i < 999999; i++); // 模拟耗时的任务
        
        System.out.println("[并发任务" + name + "]  执行完毕，通知障碍器");
        try {
            // 每执行完一项任务就通知障碍器
            cb.await();
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

[并发任务A]  开始执行
[并发任务D]  开始执行
[并发任务C]  开始执行
[并发任务B]  开始执行
[并发任务E]  开始执行
[并发任务B]  执行完毕，通知障碍器
[并发任务E]  执行完毕，通知障碍器
[并发任务D]  执行完毕，通知障碍器
[并发任务A]  执行完毕，通知障碍器
[并发任务C]  执行完毕，通知障碍器
......终于要执行最后的任务了......     //可以看出执行一组任务后,在执行这个线程任务

public class MyCountDownLatch {
    public static void main(String[] args) {
        //启动会议室线程，等待与会人员参加会议
        Conference conference = new Conference(3);
        new Thread(conference).start();
        
        //参会者线程
        for(int i = 0 ; i < 3 ; i++){
            Participater participater = new Participater("" + i , conference);
            Thread thread = new Thread(participater);
            thread.start();
        }
    }
}

/** 会场类 */
class Conference implements Runnable{
    private final CountDownLatch countDown;//障碍器
    
    public Conference(int count){
        countDown = new CountDownLatch(count);
    }
    
    /** 与会人员到达 */
    public void arrive(String name){
        System.out.println(name + "到达.....");
        
        //到达一个,锁计数器 - 1, 在计数到达0之前会一直阻塞
        countDown.countDown();
        
        System.out.println("还有 " + countDown.getCount() + "位没有到达...");
    }
    
    @Override
    public void run() {
        System.out.println("准备开会，参加会议人员总数为：" + countDown.getCount());
        
        //调用await(),等待所有的与会人员到达
        try {
            countDown.await();
        } catch (InterruptedException e) {
        }
        
        System.out.println("所有人员已经到达，会议开始.....");
    }
}

/** 参会者类*/
class Participater implements Runnable{
    private String name;
    private Conference conference;
    
    public Participater(String name,Conference conference){
        this.name = name;
        this.conference = conference;
    }

    @Override
    public void run() {
        conference.arrive(name);
    }
}

准备开会，参加会议人员总数为：3
2到达.....
还有 2位没有到达...
0到达.....
还有 1位没有到达...
1到达.....
所有人员已经到达，会议开始.....
还有 0位没有到达...

当所有的线程执行完本轮任务，同时开始下一轮任务时，意味着当前阶段已结束，
进入到下一阶段，phase的值自动加1

import java.util.Random;
import java.util.concurrent.Phaser;
import java.util.concurrent.atomic.AtomicInteger;

/**
 *可变数目: 动态注册和取消 
 *
 *示例: 
 *    在旅游过程中,有可能很凑巧遇到几个朋友,
 *    然后他们听说你们在旅游,所以想要加入一起继续接下来的旅游.
 *    也有可能,在旅游过程中,突然其中有某几个人临时有事,想退出这次旅游了
 */
public class MyPhaser_5 {
    public static void main(String[] args) {
        final int num = 3;
        Phaser phaser = new Phaser(num){
            /**
             * 如果该方法返回true，那么Phaser会被终止, 默认实现是在注册任务数为0时返回true
             * phase : 阶段数
             * registeredParties : 注册的线程数 
             */
             @Override
             protected boolean onAdvance(int phase, int registeredParties) {
                 System.out.println("" + getArrivedParties() + "个人都到齐了,第" + (phase + 1) + "次集合 \n");
                 return phase >= num;
             }
        };
        
        new Thread(new TourismRunnable(phaser),"小明").start();
        new Thread(new TourismRunnable(phaser),"小刚").start();
        new Thread(new TourismRunnable(phaser),"小红").start();
    }
}

/** 旅行线程 */
class TourismRunnable implements Runnable{
    Phaser phaser;
    /**
     * 每个线程保存一个朋友计数器,小红第一次遇到一个朋友,取名`小红的朋友0号`,第二次遇到一个朋友,取名为`小红的朋友1号`
     */
    AtomicInteger frientCount = new AtomicInteger();
    
    public TourismRunnable(Phaser phaser) {
        this.phaser = phaser;
    }
 
    @Override
    public void run() {
         switch (phaser.getPhase()){
             case 0:if(!goToPoint("出发点")) break;
             case 1:if(!goToPoint("旅游景点")) break;
             case 2:if(!goToPoint("酒店")) break;
         }
    }
 
    /**
     * @param point 目的地
     * @return 返回true,说明还要继续旅游,否则就临时退出了
     */
    private boolean goToPoint(String point){
        try {
            if(!randomEvent()){
                //取消注册
                phaser.arriveAndDeregister();
                return false;
            }
            System.out.println(Thread.currentThread().getName() + "到了" + point);
            
            //阻塞
            phaser.arriveAndAwaitAdvance();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
 
    /**
     * 随机事件: 遇到新朋友一起旅游 或者 中途退出旅游
     * @return 返回true,说明还要继续旅游,否则就临时退出了
     */
    private boolean randomEvent() {
        int random = new Random().nextInt(100);
        String name = Thread.currentThread().getName();
        
        if (random < 10){
            int friendNum =  1;
            System.out.println("=====================" + name + ":遇到了"+friendNum+"个朋友,要一起去旅游");
            
            new Thread(new TourismRunnable(phaser), name + "的朋友" + frientCount.incrementAndGet() + "号").start();
            //注册
            phaser.bulkRegister(friendNum);
            
        }else if(random > 80){
            System.out.println("=====================" + name + ":突然有事要离开一下,不和他们继续旅游了");
            return false;
        }
        
        return true;
    }
}