线程学习（33）-Semaphore,CountDown,以及CyclicBarrier

ReentrantLock,以及ReentrantReadWriteLock源码可以看懂，但是真的记不住，而且后续如果面试虽然知道流程，反正得好好表述一下。剩下的后续总结吧。而且，这么久，我也心烦了。

Semaphore

信号量，限制同时访问资源的资源上限。

package com.bo.threadstudy.eight;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Semaphore;

@Slf4j
public class SemaporeTest {
    /**
     * 测试信号量代码，可以用来做限流
     * @param args
     */
    public static void main(String[] args) {
        //捋了下流程，是通过permits来做控制的，原理应该没什么难度
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //获取资源
                try {
                    semaphore.acquire();
                    log.debug("测试信号量限流");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //来释放资源
                    semaphore.release();
                }
            }).start();
        }
    }

}

底层的话采用了共享锁的机制，tryAcquire以及tryRelease系列的方法，源码后续在说，过。

CountdownLatch

这个我前面用了很多次了，后续复习如果不了解的话，可以打死自己了。

CyclicBarrier

和CountdownLatch类似，不过在每次内部的parties为0时，默认会重新赋值成构造函数定义的初始值。

package com.bo.threadstudy.eight;

import lombok.extern.slf4j.Slf4j;

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

/**
 * countDownLatch我用了很多次，就不需要重新再来一趟了，练习一下CylicBarrier
 * 源码的话，后续再说吧，虽然看的懂，但真的记不住，而且我也不知道该怎么去说，可以理解，可以看的懂，但是就是说不清
 */
@Slf4j
public class CyclicBarrierTest {
    public static void main(String[] args) {
        //TODO 需要注意一点，在线程使用时，假如在解决生产者消费者问题时，使用cyclicBarrier时，可能会卡死
        //根据场景使用吧，源码都这么简单
        //和countDownLatch不同的是，在parties为0时，它会自动重置为构造的最大值
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
        new Thread(() -> {
            log.debug("线程刚执行");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            log.debug("线程执行结束");

        }).start();

        new Thread(() -> {
            log.debug("线程刚执行");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            log.debug("线程执行结束");

        }).start();
        new Thread(() -> {
            log.debug("线程刚执行");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            log.debug("线程执行结束");

        }).start();
        new Thread(() -> {
            log.debug("线程刚执行");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            log.debug("线程执行结束");

        }).start();
    }

}