多线程之---CountDownLatch和CylicBarrier

购买的课程总结： 随手记录一下，写的粗糙，没有涉及原理

1.CountDownLatch

CountDownLatch是一个计数器向下减的闭锁，通过它可以完成类似于阻塞当前线程的功能，即：一个线程或多个线程一直等待，直到其他线程执行的操作完成。
常结合：信号量Semapore 控制线程同时的并发数

参考地址：多线程之— 信号量Semaphore

package cn.sys.Test.thread.atomic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @description: CountDownLatch结合Semaphore 使用
 * @author: Cc
 * @data: 2020/7/27 10:06
 */
@Slf4j
public class thread2_2 {

    //同时并发执行的总数
    private static int threadTotal = 4;
    //请求总数
    private static int clientTotal = 4;

    static ExecutorService executor = Executors.newCachedThreadPool();

    public static void main(String[] args) throws InterruptedException {
        ThBean thBean = new ThBean();
        //信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //请求总数
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        executor.execute(() -> {
            try {
                //申请一个可用的信号量，如果没有可用线程则会阻塞在这里，不能结束该方法，不能返回，直到有可用的资源为止
                semaphore.acquire();
                
                //模拟业务逻辑
                thBean.setName1("线程1运行成功");
				
				//如果这里休眠10s中，那么主线程将会阻塞10s中。因为countDownLatch必须为0时，主线程才会继续往下执行，否则会一直阻塞
				//Thread.sleep(10000);

                //释放信号量
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //减1
            countDownLatch.countDown();
        });

        executor.execute(() -> {
            try {
                semaphore.acquire();

                //模拟业务逻辑
                thBean.setName2("线程2运行成功");

                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //减1
            countDownLatch.countDown();
        });

        executor.execute(() -> {
            try {
                semaphore.acquire();

                //模拟业务逻辑
                thBean.setName3("线程3运行成功");

                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //减1
            countDownLatch.countDown();
        });
		//如果此线程注释，那么主线程将一直阻塞
        executor.execute(() -> {
            try {
                semaphore.acquire();
                //模拟业务逻辑
                thBean.setName4("线程4运行成功");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //减1
            countDownLatch.countDown();
        });

        System.out.println("线程_1执行结果：" + thBean.getName1());
        System.out.println("线程_2执行结果：" + thBean.getName2());
        System.out.println("线程_3执行结果：" + thBean.getName3());
        System.out.println("线程_4执行结果：" + thBean.getName4());
        System.out.println("主线程阻塞中-------------------------------------------------");

        //阻塞：如果countDownLatch的值不为0，则一直阻塞
        countDownLatch.await();

        executor.shutdown();
        System.out.println("主线程开始运行中-------------------------------------------------");
        System.out.println("线程_1执行结果：" + thBean.getName1());
        System.out.println("线程_2执行结果：" + thBean.getName2());
        System.out.println("线程_3执行结果：" + thBean.getName3());
        System.out.println("线程_4执行结果：" + thBean.getName4());
    }

}

运行结果：
4个线程成功执行之后，countDownLatch的值为0时，则运行主线程

线程_1执行结果：线程1运行成功
线程_2执行结果：线程2运行成功
线程_3执行结果：线程3运行成功
线程_4执行结果：线程4运行成功
主线程阻塞中-------------------------------------------------
主线程开始运行中-------------------------------------------------
线程_1执行结果：线程1运行成功
线程_2执行结果：线程2运行成功
线程_3执行结果：线程3运行成功
线程_4执行结果：线程4运行成功

此时如果我将线程4注释，那么主线程将会一直阻塞

线程_1执行结果：线程1运行成功
线程_2执行结果：线程2运行成功
线程_3执行结果：线程3运行成功
线程_4执行结果：null
主线程阻塞中-------------------------------------------------

2.CylicBarrier

CyclicBarrier允许一组线程在到达某个栅栏点(common barrier point)互相等待，直到最后一个线程到达栅栏点，栅栏才会打开，处于阻塞状态的线程恢复继续执行。
就比如说我们在打王者的时候，十个人必须全部加载到100%，才可以开局。否则只要有一个人没有加载到100%,那这个游戏就不能开始。先加载完成的玩家必须等待最后一个玩家加载成功才可以

代码示例

@Slf4j
public class CyclicBarrierExample1 {
    //定义屏障线程数为5
    private static CyclicBarrier barrier = new CyclicBarrier(2);
    
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 6; i++) {
            final int threadNum = i;
            Thread.sleep(1000);
            executor.execute(() -> {
                try {
                    race(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        executor.shutdown();
    }
    private static void race(int threadNum) throws Exception {
        Thread.sleep(1000);
        log.info("{} 准备", threadNum);
        //完成线程等待设定的屏障数为5时，往下执行，不足为5时 再次等待
        barrier.await();
        log.info("{} 完成了", threadNum);
    }
}

执行结果

17:41:03.539 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 0 准备
17:41:04.538 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 1 准备
17:41:04.538 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 1 完成了
17:41:04.538 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 0 完成了
17:41:05.539 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 2 准备
17:41:06.539 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 3 准备
17:41:06.539 [pool-1-thread-1] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 3 完成了
17:41:06.539 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 2 完成了
17:41:07.540 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 4 准备
17:41:08.540 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 5 准备
17:41:08.540 [pool-1-thread-3] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 5 完成了
17:41:08.540 [pool-1-thread-2] INFO com.mmall.concurrency.example.aqs.CyclicBarrierExample1 - 4 完成了

3.CountDownLatch 和 CylicBarrier 区别

CountDownLatch	CylicBarrier
不可重复利用	可重复利用
1个或N个线程需要等待其他线程完成某项操作之后才能继续往下执行操作，描述的是1个线程或N个线程等待其他线程的关系	多个线程之间相互等待，直到所有的线程都满足了条件之后各自才能继续执行后续的操作，描述的多个线程内部相互等待的关系。
减计数方式	加计数方式
调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响	调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞（参考例子得出的结论）