关于JUC——java.util.concurrent下典型的类

· ReentrantLock

· Semaphore

· CountDownLatch

· CyclicBarrier

---

1、ReentrantLock：可重入锁

老朋友了，看前面博客

2、Semaphore：信号量

可以实现限流 *** 作，给一个线程池添加多个任务，借助信号量可以实现对线程执行情况的控制：

两个重要的方法：

①semaphore.acquire（）获得信号量

②semaphore.release（）释放信号量

/**
 * 信号量：实现限流
 */
public class SemaphoreDemo1 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service =Executors.newFixedThreadPool(5);

        //创建信号量
        Semaphore semaphore = new Semaphore(2);

        //统一的任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Thread currThread= Thread.currentThread();//获得当前的线程
                System.out.println("进入线程："+currThread.getName());
                try {
                    //获取令牌
                    semaphore.acquire();//如果没有可用令牌，那么线程会阻塞在当前位置
                    System.out.println(currThread.getName()+":得到了令牌 | Time:"+
                            LocalDateTime.now());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println(currThread.getName()+":释放了令牌 | Time:"+
                            LocalDateTime.now());
                    //释放令牌
                    semaphore.release();
                }
            }
        };
        //提交任务给线程池执行
        service.submit(runnable);

        //提交任务给线程池执行
        service.submit(runnable);

        //提交任务给线程池执行
        service.submit(runnable);

        //提交任务给线程池执行
        service.submit(runnable);

        //提交任务给线程池执行
        service.submit(runnable);

    }
}

3、CountDownLatch：计数器

在多个线程中，可以用join等待所有的线程都执行结束，而在线程池中呢？join就不行了，这个时候可以使用CountDownLatch，来判断线程池中的任务是否已经全部执行完。比如比赛的时候需要等所有选手到达终点之后再公布成绩。

两个重要方法：

①countDown：计数器-1

②await：阻塞等待，所有的任务全部执行完（等待CountDownLatch==0）

/**
 * 计数器在线程中的使用
 */
public class CountDownLatchDemo1 {
    public static void main(String[] args) throws InterruptedException {
        //创建计数器
        CountDownLatch countDownLatch = new CountDownLatch(5);

        //创建新线程执行任务
        for (int i =1 ; i <6 ; i++) {
            int finalI = i;
            new Thread(()->{
                Thread currThread = Thread.currentThread();
                System.out.println(currThread.getName()+"开始起跑");
                //跑步所用的时间
                try {
                    int runTime = (1+new Random().nextInt(5));
                    TimeUnit.SECONDS.sleep(runTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("当前选手到达终点："+ finalI);
                countDownLatch.countDown();
            },"选手-"+i).start();

        }
        countDownLatch.await();
        System.out.println("比赛结束");
    }
}

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

/**
 * 计数器在线程池中的使用
 */
public class CountDownLatchDemo2 {
    public static void main(String[] args) throws InterruptedException {
        //创建计数器
        CountDownLatch countDownLatch = new CountDownLatch(2);

        //创建线程池

        ExecutorService service = Executors.newFixedThreadPool(5);

        //给线程池添加任务
        for (int i = 0; i < 2; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    Thread currThread = Thread.currentThread();
                    System.out.println("线程名称："+currThread.getName());
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(currThread.getName()+"执行结束");
                    countDownLatch.countDown();
                }
            });

        }
        countDownLatch.await();
        System.out.println("比赛结束");


    }
}

4、CyclicBarrier：循环屏障

通过循环屏障可以实现对多线程的并发控制，只有被阻塞的线程数量到达指定值时屏障才会放行。实际上，它也可以看作一个倒计时器，倒计时数的最大值即为屏障值，每个线程调用了await方法都会使倒计时器的数减一，当倒计时数的值为零时，冲破屏障，继续执行下面的代码。再举一个简单的例子，冲破屏障就像现实生活中大坝泄洪，等水到达一定量时，再进行开闸放水，只不过这个过程是循环的，泄完这一波，又重新开始储水，等到达一定量时再继续泄。

 

/**
 * 循环屏障
 */
public class CyclicBarrierDemo1 {
    public static void main(String[] args) throws InterruptedException {

        //循环屏障
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("计数器为0了");
            }
        });
        //创建线程池
         ExecutorService service =Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(()->{
                Thread currThread = Thread.currentThread();
                System.out.println("执行线程："+currThread.getName());
                try {
                    Thread.sleep(500* finalI);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    cyclicBarrier.await();//执行阻塞（计数器-1，阻塞等待，直到循环屏障的计数器为0的时候，再执行后面的代码）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("线程执行完成："+currThread.getName());
            });
        }
    }
}

结果展示：