countDownLatch和cyclicBarrier、semaphore--屎上最臭的解析

今天来聊一下，拉屎的问题：

1、阿姨要打扫男厕所，发现有10个人在拉屎，阿姨非常尊重男性隐私，等10个人全拉完出来了，才开始打扫。

2、社区举行拉屎比赛，每满10个人到场就可以开拉（社区厕所真大）

3、15人想拉屎，只有5个蹲位，先找到蹲位，先拉，否则等待，拉完让出蹲位

那么，怎么来实现这三个问题呢，我们一一来看：

问题1，由CountDownLatch来帮助阿姨

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；（比如主线程等某个数量的子线程：火箭发射前，需要检查各个部件，检查部件的子线程都完成后，告诉主线程去发射；）

package countDownCyclicBarrialSemaphore;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args){
        final int count = 3;
        final CountDownLatch latch = new CountDownLatch(count);
        System.out.println("阿姨要打扫男厕所，发现有"+count+"个人在拉屎，阿姨非常尊重男性隐私，等人全拉完出来了，才开始打扫");

        for(int i = 1; i<=count;i++){
            new Thread("拉屎客-"+i+":"){
                @Override
                public void run(){
                    System.out.println(Thread.currentThread().getName()+"阿姨，不好意思，等我一会儿");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"阿姨，我拉完了");
                    latch.countDown();
                }
            }.start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("所有人终于出来了，开始打扫");

    }
}

输出：

阿姨要打扫男厕所，发现有3个人在拉屎，阿姨非常尊重男性隐私，等人全拉完出来了，才开始打扫
拉屎客--1阿姨，不好意思，等我一会儿
拉屎客--2阿姨，不好意思，等我一会儿
拉屎客--3阿姨，不好意思，等我一会儿
拉屎客--2阿姨，我拉完了
拉屎客--3阿姨，我拉完了
拉屎客--1阿姨，我拉完了
所有人终于出来了，开始打扫

问题2由CyclicBarrier来帮助社区

CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

package countDownCyclicBarrialSemaphore;

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

/**
 * Created by wyyangyang1 on 2019/5/20.
 */
public class CyclicBarrierTest {
    public static void main(String[] args){
        final int count = 5;
        final CyclicBarrier barrier = new CyclicBarrier(count);

        for(int i=1;i<=2*count+2;i++){//正常示例，注意，此处大于count的倍数，
            new Thread("拉屎参赛者："+i){
                @Override
                public void run(){
                    System.out.println(Thread.currentThread().getName()+":我蹲好了，等人齐");
                    try {
                        barrier.await();
                        System.out.println(Thread.currentThread().getName()+":人齐了,开拉");
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        System.out.println(Thread.currentThread().getName()+":有人犯规，我退赛");
//                        e.printStackTrace();
                    }

                }
            }.start();
        }
        try {
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName()+":我是分割线————————————————————————————");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for(int i=1;i<=count-3;i++){//超时示例
            new Thread("内急的拉屎参赛者"+i){
                @Override
            public void run(){
                    System.out.println(Thread.currentThread().getName()+":我蹲好了，等人齐");
                    try {
                        barrier.await(2000, TimeUnit.MILLISECONDS);//其中一个线程超时，抛出超时异常，其他等待状态的，抛出BrokenBarrierException
                        System.out.println(Thread.currentThread().getName()+":人齐了,开拉");
                    }catch (TimeoutException e) {
                        System.out.println(Thread.currentThread().getName()+":等半天了，实在憋不住了，不等了，开拉");
//                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        System.out.println(Thread.currentThread().getName()+":有人犯规，我退赛");
//                        e.printStackTrace();
                    }

                }
            }.start();
        }




    }
}

输出：

拉屎参赛者：2:我蹲好了，等人齐
拉屎参赛者：5:我蹲好了，等人齐
拉屎参赛者：6:我蹲好了，等人齐
拉屎参赛者：4:我蹲好了，等人齐
拉屎参赛者：3:我蹲好了，等人齐
拉屎参赛者：9:我蹲好了，等人齐
拉屎参赛者：1:我蹲好了，等人齐
拉屎参赛者：10:我蹲好了，等人齐
拉屎参赛者：8:我蹲好了，等人齐
拉屎参赛者：7:我蹲好了，等人齐
拉屎参赛者：12:我蹲好了，等人齐
拉屎参赛者：11:我蹲好了，等人齐
拉屎参赛者：2:人齐了,开拉
拉屎参赛者：6:人齐了,开拉
拉屎参赛者：9:人齐了,开拉
拉屎参赛者：3:人齐了,开拉
拉屎参赛者：7:人齐了,开拉
拉屎参赛者：8:人齐了,开拉
拉屎参赛者：10:人齐了,开拉
拉屎参赛者：1:人齐了,开拉
拉屎参赛者：4:人齐了,开拉
拉屎参赛者：5:人齐了,开拉
main:我是分割线————————————————————————————
内急的拉屎参赛者1:我蹲好了，等人齐
内急的拉屎参赛者2:我蹲好了，等人齐
内急的拉屎参赛者2:等半天了，实在憋不住了，不等了，开拉
内急的拉屎参赛者1:有人犯规，我退赛
拉屎参赛者：12:有人犯规，我退赛
拉屎参赛者：11:有人犯规，我退赛

问题三，由samaphore来帮助大家等待

samaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

package countDownCyclicBarrialSemaphore;

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args){
        final int renNum = 5;
        final int dunkenNum = 2;

        final Semaphore semaphore = new Semaphore(dunkenNum);

        for(int i=1; i<=renNum;i++){
            new Thread("拉屎人："+i){
                @Override
            public void run(){
                    System.out.println(Thread.currentThread().getName()+":我想拉屎");
                    try {
                        semaphore.acquire();

                        System.out.println(Thread.currentThread().getName()+":我找到蹲坑，开始拉屎");
                        Thread.sleep(4000);

                        semaphore.release();
                        System.out.println(Thread.currentThread().getName()+":我拉完了。。。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }
    }
}

输出：

拉屎人：1:我想拉屎
拉屎人：4:我想拉屎
拉屎人：5:我想拉屎
拉屎人：3:我想拉屎
拉屎人：2:我想拉屎
拉屎人：4:我找到蹲坑，开始拉屎
拉屎人：1:我找到蹲坑，开始拉屎
拉屎人：1:我拉完了。。。
拉屎人：3:我找到蹲坑，开始拉屎
拉屎人：5:我找到蹲坑，开始拉屎
拉屎人：4:我拉完了。。。
拉屎人：3:我拉完了。。。
拉屎人：5:我拉完了。。。
拉屎人：2:我找到蹲坑，开始拉屎
拉屎人：2:我拉完了。。。

大家应该印象非常深刻了。。。。。。。