CountDownLatch、CyclicBarrier、Semaphore 三者之间的区别和使用

CountDownLatch类计数器的使用

主要有两个方法，当一个或者多个线程调用await()方法时，调用的线程会被阻塞，其它线程调用countDown()方法时将计数器减去1(调用countDown()方法的线程不会被阻塞)，但计数器的值变为0时，因为调用await()方法被阻塞的线程会被唤醒，继续执行。

代码举例：

package com.countdownlatch;

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch  类计数器的使用
 * CountDownLatch  主要有两个方法，当一个或者多个线程调用await()方法时，调用线程会被阻塞，
 * 其它线程调用countDown()方法将计数器减 1 (调用countdown()方法的线程不会被阻塞)，
 * 但计数器的值变为零时，因调用await()方法被阻塞的线程会被唤醒，继续执行。
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t 国，被灭");
                count.countDown();//逐个减一，只有所有的线程执行完成，才会执行下面的代码(倒计数 )
            }, CountDownLatchEnum.getMessenger(i).getRetMessenger()).start();
        }
        count.await();//判断上面的线程是否执行完成，若未完成；则返回上面继续执行，直到上面的线程执行完成，才会执行下面的代码
        System.out.println(Thread.currentThread().getName().replaceAll("main","秦") + "\t 国，统一六国");
    }
}

枚举辅助类：

package com.countdownlatch;


/**
 * CountDownLatch 的枚举辅助类
 */
public enum CountDownLatchEnum {
    ONE(1, "齐"), TWO(2, "楚"), THREE(3, "燕"), FORE(4, "韩"), FINE(5, "赵"), SIT(6, "魏");
    private int retCode;
    private String retMessenger;

    public int getRetCode() {
        return retCode;
    }

    public String getRetMessenger() {
        return retMessenger;
    }

    CountDownLatchEnum(int retCode, String retMessenger) {
        this.retCode = retCode;
        this.retMessenger = retMessenger;
    }

    public static CountDownLatchEnum getMessenger(int index) {
        CountDownLatchEnum[] elemts = CountDownLatchEnum.values();
        for (CountDownLatchEnum iter : elemts) {
            if (iter.getRetCode() == index) {
                return iter;
            }
        }
        return null;
    }
}

CyclicBarrier类型的用法正好和CountDownLatch意思相反

等所有线程都收集完成，才会执行下一个方法；比如：7个人会议，只有7个人全部到齐了才可以开会，否则只能等着。

代码举例：

package com.countdownlatch;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * CyclicBarrier  等所有的线程都收集完成，才会执行下一个方法；比如：7个人会议；只有7个人
 * 全部到齐了才可以开会；否则只能等着。
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("人员到齐，会议开始....");
        });
        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t 签到...");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, CyclicBarrierEnum.getMessenger(i).getRetMessenger()).start();
        }
    }
}

枚举辅助类：

package com.countdownlatch;


/**
 * CyclicBarrier 的枚举辅助类
 */
public enum CyclicBarrierEnum {
    ONE(1, "班长"), TWO(2, "副班长"), THREE(3, "学习委员"), FORE(4, "纪律委员"), FINE(5, "生活委员"), SIT(6, "劳动委员"), SERVE(7, "团支书");
    private int retCode;
    private String retMessenger;

    public int getRetCode() {
        return retCode;
    }

    public String getRetMessenger() {
        return retMessenger;
    }

    CyclicBarrierEnum(int retCode, String retMessenger) {
        this.retCode = retCode;
        this.retMessenger = retMessenger;
    }

    public static CyclicBarrierEnum getMessenger(int index) {
        CyclicBarrierEnum[] elemts = CyclicBarrierEnum.values();
        for (CyclicBarrierEnum iter : elemts) {
            if (iter.getRetCode() == index) {
                return iter;
            }
        }
        return null;
    }
}

SemapJore 信号量(灯）

主要有两个目的：1、多个共享资源的互斥使用

2、用于并发线程数的控制

代码举例：

package com.countdownlatch;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * Semaphore 信号量(灯)主要用于两个目的：一是多个共享资源的互斥使用，另一个用于并发线程数的控制
 * <p>
 * 比如：争车位，开走一辆，进入一辆，没位置的只能等着，只要有其它车辆开走，立马抢空车位。
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        //模拟 3 个停车位
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {//6辆车去抢三个车位
            new Thread(() -> {
                try {
                    semaphore.acquire();//抢到车位，停车场的空位减 1
                    System.out.println(Thread.currentThread().getName() + "\t 抢到车位");
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }//停3 秒后离开停车场
                    System.out.println(Thread.currentThread().getName() + "\t 停车3秒后,离开停车场");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();//离开停车场，释放停车场的位置；让其它车辆争抢位置
                }
            }, String.valueOf(i)).start();
        }

    }
}