CountDownLatch、 CyclicBarrier 和 semaphore的使用

CountDownLatch、 CyclicBarrier 和 semaphore的介绍

countDownLatch：
CountDownLatch类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。

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

Semaphore类提供了一个计数信号量。通过Semaphore类，可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。Semaphore的构造函数中带有一个fairness的参数，用于设置是否“公平”。当fairness为true时，Semaphore保证各线程以后进先出（FIFO）的方式获得信号量。如果fairness为false，则不保证这种顺序

CountDownLatch、 CyclicBarrier 和 semaphore的使用·

CountDownLatch的例子

public class CountDownTest {
    public static void main(String[] args) {
        //5代表线程数量
        final CountDownLatch countDownLatch = new CountDownLatch(5);
        System.out.println("多线程准备阶段!");
        for (int i = 0; i < 5; i++){
            new Thread(){
                @Override
                public void run() {
                    System.out.println("线程名称:>>>" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(100);
                    } catch (Exception e){
                        e.printStackTrace();
                    }
                    //计算线程完成情况
                    countDownLatch.countDown();
                }
            }.start();
        }

        try {
            //等待所有线程完成再执行此语句
            countDownLatch.await();
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("多线程完成阶段：SUCCESS！");
    }
}

CyclicBarrier的例子

public class CyclicBarrierTest1 {
    public static void main(String[] args) {
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    System.out.println("Thread1 到达指定集合地点！");
                    cyclicBarrier.await();
                    Thread.sleep(1000);
                    System.out.println("Thread1 等待其他成员到达指定到底，我来看看是否还缺人...");
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(10000);
                    System.out.println("Thread2 到达指定集合地点！");
                    cyclicBarrier.await();
                    Thread.sleep(2000);
                    System.out.println("Thread2 等待其他成员到达指定到底，我来看看是否还缺人...");
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }.start();

        try {
            cyclicBarrier.await();
            Thread.sleep(3000);
            System.out.println("所有成员都已经到达指定集合地点，开始出发去玩！");
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

Semaphore的例子

package com.lte.threadtest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
 
public class SemaphoreTest {
        public static void main(String[] args) {
              ExecutorService service = Executors. newCachedThreadPool();
               final Semaphore sp = new Semaphore(3);
               for (int i = 0; i < 10; i++) {
                     Runnable runnable = new Runnable() {
                            public void run() {
                                   try {
                                         sp.acquire();
                                  } catch (InterruptedException e1) {
                                         e1.printStackTrace();
                                  }
                                  System. out.println("线程" + Thread.currentThread().getName() + "进入，当前已有" + (3 - sp.availablePermits()) + "个并发" );
                                   try {
                                         Thread. sleep((long) (Math. random() * 10000));
                                  } catch (InterruptedException e) {
                                         e.printStackTrace();
                                  }
                                  System. out.println("线程" + Thread.currentThread().getName() + "即将离开");
                                  sp.release();
 
                                   // 下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
                                   // availablePermits()指的是当前信号灯库中有多少个可以被使用
                                  System. out.println("线程" + Thread.currentThread().getName() + "已离开，当前已有" + (3 - sp.availablePermits()) + "个并发" );
                           }
                     };
                     service.execute(runnable);
              }
       }
 
}