JUC随笔01-JUC构成

什么是JUC？

JUC指的是。java-jdk中rt.jar包下的java.util.concurrent包下的所有类

JUC主要包括哪些？

1.atomic包(原子操作类)

主要通过CAS算法来实现并发下的原子操作(以下以AtomicInteger为例)

AtomicInteger中常规调用的是上面这个方法来进行+1操作，在getAndAddInt方法中调用 compareAndSwap***方法来判断，如果原来的值与CPU底层的值相同，则进行修改操作，不然则继续循环。

这时候出现了LongAdder，其大致原理也是使用CAS算法来实现原子性的相加但是它在高并发下的性能更好

AtomicLong与LongAdder的区别参考https://blog.csdn.net/caoyuanyenang/article/details/84587386

2.CountDownLatch(多线程计数器)

CountDownLatch的构造方法主要是传入一个计数的值，然后在线程中调用countDown方法来进行计数，当计数器的值等于0的时候，所有在调用CountDownLatch的await方法会继续往下执行。

主要用途：并行计算。(当做的任务可以拆分成相同的多个子任务，并且当所有完成后对结果进行处理)

3.Semaphore(信号量)

简单的说就是，某个资源可以被同时访问的个数。
主要方法有：acquire、release

 	//请求总数
    public static int clientTotal = 5000;
    //线程总数
    public static int threadTotal = 500;
    //计数
    public  static LongAdder count = new LongAdder();
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire(); //获得许可
                    add();
                    semaphore.release(); //始放许可
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown(); //关闭线程
    }

    private static void add() {
        count.increment();
    }

4.CyclicBarrier(同步类)

实现多个线程间相互等待，直到满足关系的时候才继续执行操作

计数器可以用reset方法重置

 private static CyclicBarrier cyclicBarrier = new CyclicBarrier(5,()->{
        System.out.println("执行操作");
    });
    public static void main(String[] args) throws Exception {

        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 50; i++) {
            final int num = i;
            Thread.sleep(1000);
            exec.execute(() -> {
                try {
                    test(num);
                } catch (Exception e) {
                    log.error("exception ", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int num) throws Exception{
        log.info("do ready : {}",num);
        cyclicBarrier.await();
        log.info("do result : {}",num);
    }

初始化的时候传入的数字为，等待5个 线程调用await方法后才继续进行操作

4.Lock(锁相关)

5.BlockQueue(阻塞队列)

6.线程池

7.FutureTask

未完待续。。。