并发编程JUC系列AQS（CountDownLatch、CyclicBarrier、Semaphore）

一、CountDownLatch

package com.jonychen.test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 并发编程java.util.concurrent(JUC)
 * AQS(AbstractQueuedSynchronizer)
 */
public class JUCAQSDemo {
    public static void main(String[] args){
/**
 * CountDownLatch用来控制一个线程等待多个线程，维护一个计数器cnt，
 * 每次调用countDown()会让计数器的值减一， 减到零时，
 * 那些因为调用await()方法而在等待的线程会被唤醒
 */
        final  int totalThread=10;
        CountDownLatch countDownLatch =new CountDownLatch(totalThread);
        ExecutorService executorService =Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(()->{
                System.out.println("jonychen run");
                countDownLatch.countDown();
            });
        }
        try {
            countDownLatch.await();
            System.out.println("end...");
            executorService.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行截图：

二、CyclicBarrier

package com.jonychen.thread;

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

/**
 * 并发编程java.util.concurrent(JUC)
 * AQS(AbstractQueuedSynchronizer)
 */
public class JUCAQSCycliBarrier {
/**
*CyclicBarrier用来控制多个线程相互等待，只有当多个线程都到达时，这些线程才会继续执行，
* 和CountDownLatch相似，都是通过维护计数器实现的，但他的计数器是递增的。每次执行await（）
* 方法后，计数器会加1，直到计数器的值和设置的值相同，等待的所有线程才会继续执行，和CountDownLatch
* 的另一个区别是，CyclicBarrier的计数器可以循环使用，所以才叫他循环屏障
  */
    public static void main(String[] args){
        final int totalThread=10;
        CyclicBarrier cyclicBarrier =new CyclicBarrier(totalThread);
        ExecutorService executorService=Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(()->{
                System.out.println("before..*");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.print("after   ");
            });
        }
        executorService.shutdown();
    }
}

运行截图：

三、Semaphore

package com.jonychen.thread;

import sun.misc.Cleaner;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 并发编程java.util.concurrent(JUC)
 * AQS(AbstractQueuedSynchronizer)
 */
public class JUCAQSSemaphore {

    public static void main(String[] args){
        /**
      *Semaphore就是操作系统中的信号量，可以控制对互斥资源的访问线程数
      *以下代码模拟了对某个服务的并发请求，每次只能有30个客户端同时访问，请求总数为 10。
      */
        final int clientCount=30;
        final int totalRequestCount=10;
        Semaphore semaphore =new Semaphore(clientCount);
        ExecutorService executorService=Executors.newCachedThreadPool();
        for (int i = 0; i < totalRequestCount; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    System.out.println(semaphore.availablePermits() + "");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();
    }
}

运行截图：