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);    }}

准备开会，参加会议人员总数为：32到达.....还有 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;    }}