JUC高并发编程(五)——常用辅助类的使用

目录

1、CountDownLatch 类

2、CyclicBarrier 类

3、Semaphore 类

---

1、CountDownLatch 类

官方解释：

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。

通俗解释：

就是自己设置一个计数器，将计数器传入该类的有参构造方法，在多线程执行时可以通过该类的countDown方法给计数器减1，在计数器到达零之前，该类的await方法式阻塞的，没法执行await方法后面的代码（await后面主线程的代码),只有计数器到达零才会执行。

问题：教室有六个学生和班长，当六个学生都随机离开教室后，班长才关闭教室门。

package com.example.juc_assist_class;

import java.util.concurrent.CountDownLatch;

/**
 * 多线程编程辅助类实践
 */
public class CountDownDemo {
    //创建计数器
    private static int number =6;
    public static void main(String[] args) throws InterruptedException {

        //------------------------CountDownLatch减少计数辅助类-----------------------

        CountDownLatch countDownLatch = new CountDownLatch(number);

        for (int i = 1; i <=number; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "号同学离教室");
                //计数器减1
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"班长锁门");

    }
}

2、CyclicBarrier 类

官方解释：

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。

：问题：集齐七颗龙珠才能召唤神龙。

package com.example.juc_assist_class;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    //创建固定值
    private static  int number=7;

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(number, () -> {
            System.out.println("集齐七颗龙珠,召唤神龙");
        });

        //集齐七颗龙珠的过程
        for (int i = 1; i <=number; i++) {
            new Thread(()->{
                try {
                    System.out.println("第"+Thread.currentThread().getName()+"颗龙珠被收集");
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

3、Semaphore 类

官方解释：

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

问题：六辆车同时抢占三个车位

package com.example.juc_assist_class;

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 模拟六辆汽车，停三个车位
 */
public class SemaphoreDemo {
    //创建许可数量
    private static  int number=3;

    public static void main(String[] args) {
        //设置许可数量
        Semaphore semaphore = new Semaphore(number);
        //六辆汽车抢占车位
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    //抢占
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢占到了停车位");
                    //随机停车时间
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+"-----离开停车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //释放车位
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}