前入式JUC常用类源码分析

大家好，欢迎来到IT知识分享网。

CountDownLatch

public class CountDownDemo { 
    / * countdown倒计时的意思;允许一个或者多个线程被阻塞,等待其他线程执行完在被唤醒,有点类似join * 应用场景:可以用来控制并发量,在某个条件之后实现秒杀 * @param args */ public static void main(String[] args) throws InterruptedException { 
    CountDownLatch countDownLatch = new CountDownLatch(3); //3-1 new Thread(countDownLatch::countDown).start(); //2-1 new Thread(countDownLatch::countDown).start(); //1-1=0 new Thread(countDownLatch::countDown).start(); countDownLatch.await(); //等待countdown次数被减完,再去唤醒主线程 System.out.println("主线程执行完~"); } } 

下面简单展示一下秒杀操作

public class MyCountDownLatch implements Runnable { 
    static CountDownLatch countDownLatch = new CountDownLatch(1); public static void main(String[] args) { 
    for (int i = 0; i < 100; i++) { 
    new Thread(new MyCountDownLatch(), "myCountDownThread" + i).start(); } System.out.println("2秒后执行秒杀操作吧！"+ System.currentTimeMillis()); try { 
    TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { 
    e.printStackTrace(); } countDownLatch.countDown(); } @Override public void run() { 
    try { 
    countDownLatch.await(); System.out.println("wait for countDownLatch: " + System.currentTimeMillis()); } catch (InterruptedException e) { 
    e.printStackTrace(); } } } // print result 2秒后执行秒杀操作吧！55 wait for countDownLatch: 56 wait for countDownLatch: 56 wait for countDownLatch: 56 wait for countDownLatch: 56 wait for countDownLatch: 56 wait for countDownLatch: 56 wait for countDownLatch: 56 wait for countDownLatch: 56 ... // 大概看了90%的误差在1ms 

那光会用还远远不够啊，接下来我们到胃深入一下看看

countDownLatch先到这里

Semaphore

顾名思义就是我们停车场的信号灯，可以控制同时可以访问的线程数，类似限流的作用

public class MySemaphore { 
    static Semaphore semaphore = new Semaphore(5); public static void main(String[] args) { 
    for (int i = 0; i < 20; i++) { 
    new Thread(new Car(i, semaphore)).start(); } } static class Car implements Runnable{ 
    private Integer carId; private Semaphore carSemaphore; public Car(Integer carId, Semaphore semaphore) { 
    this.carId = carId; this.carSemaphore = semaphore; } @Override public void run() { 
    try { 
    carSemaphore.acquire(); System.out.println("第"+carId+"辆车进来了"); TimeUnit.SECONDS.sleep(4); System.out.println("第"+carId+"辆车走了"); carSemaphore.release(); } catch (InterruptedException e) { 
    e.printStackTrace(); } } } } // print result 第0辆车进来了 第3辆车进来了 第2辆车进来了 第1辆车进来了 第5辆车进来了 第5辆车走了 第3辆车走了 第2辆车走了 第4辆车进来了 第7辆车进来了 第0辆车走了 第1辆车走了 第8辆车进来了 第6辆车进来了 第11辆车进来了 // 停车场最多停5辆车 第11辆车走了 第4辆车走了 第9辆车进来了 第7辆车走了 第6辆车走了 第13辆车进来了 第8辆车走了 第14辆车进来了 第12辆车进来了 第10辆车进来了 第14辆车走了 第9辆车走了 第10辆车走了 第12辆车走了 第13辆车走了 

用力深入进去发现又有AQS不愧是并发的核心啊

CyclicBarrier

表面上看起来是一个可循坏使用的屏障，线程到达屏障会被阻塞直到，一组线程全部到达屏障时候才会继续工作

public class MyCyclicBarrier implements Runnable{ 
    @Override public void run() { 
    System.out.println("最后进行筛选处理"); } public static void main(String[] args) { 
    CyclicBarrier cyclicBarrier = new CyclicBarrier(4, new MyCyclicBarrier()); new TestThread("my girl1", cyclicBarrier).start(); new TestThread("my girl2", cyclicBarrier).start(); new TestThread("my girl3", cyclicBarrier).start(); new TestThread("my girl4", cyclicBarrier).start(); } static class TestThread extends Thread{ 
    private String name; private CyclicBarrier cb; public TestThread(String name, CyclicBarrier cb) { 
    this.name = name; this.cb = cb; } @Override public void run() { 
    try { 
    System.out.println(name); cb.await(); } catch (InterruptedException | BrokenBarrierException e) { 
    e.printStackTrace(); } } } } // print result my girl1 my girl4 my girl3 my girl2 最后进行筛选处理