JUC强大辅助类

CountDownLatch(减少计数)

例子

题目： 现在教室里一共七个人，六位同学，一位班长，要求六位同学走之后班长才能锁门离开。写程序模拟：

public class CountDownLatchDemo {
    public static void main(String[] args) {
        for(int i=1;i<=6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"号同学离开教室");
            },String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName()+"班长离开教室锁门");
    }
}

运行结果：
且每次运行的结果都一定。
分析： 因为六个线程的start时间不一定,所以这个代码肯定不行。这时候CountDownLatch就可以用到了。CountDownLatch就适用于之前需要做什么什么操作，步骤一定，最后做什么，这样的需求。

代码实现:

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for(int i=1;i<=6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"号同学离开教室");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"班长离开教室锁门");
    }
}

运行结果：
问题解决！！！

原理

• CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞
• 其他线程调用countDown方法会将计数器减1（调用countDown方法的线程不会阻塞）
• 当计数器的值变为0时，因await阻塞的线程就会被唤醒，继续执行。

CyclicBarrier(循环栅栏)

例子

/**
 * 集齐七颗龙珠召唤神龙
 */
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("集齐七颗龙珠召唤神龙");
        });
        for(int i=1;i<=7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"星龙珠被收集");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

原理

CyclicBarrier的字面意思是可循环使用的屏障。它要做的事情是让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

Semaphore（信号灯）

例子

/**                                                                                                   
 * 六辆车争夺三个停车位                                                                                         
 */                                                                                                   
public class SemaphoreDemo {                                                                          
    public static void main(String[] args) {                                                          
        // 三个停车位                                                                                      
        Semaphore sp = new Semaphore(3);                                                              
        // 停六辆车                                                                                       
        for(int i=1;i<=6;i++){                                                                        
            new Thread(()->{                                                                          
                try {                                                                                 
                    sp.acquire();                                                                     
                    System.out.println(Thread.currentThread().getName()+"号车驶入停车位");                   
                    TimeUnit.SECONDS.sleep(3);                                                        
                    System.out.println(Thread.currentThread().getName()+"号车驶出停车位");                   
                } catch (InterruptedException e) {                                                    
                    e.printStackTrace();                                                              
                }finally {                                                                            
                    sp.release();                                                                     
                }                                                                                     
            },String.valueOf(i)).start();                                                             

原理

在信号量上我们定义两种操作：

• acquire(获取)：当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
• release(释放)实际上会将信号量的值加1，然后唤醒等待的线程。
• 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。