多线程编程辅助类的使用CountDownLatch、CyclicBarrier和Semaphore

上文，我们主要讲了线程池的相关知识，这篇文章主要讲讲那些配合线程池使用的辅助类：CountDownLatch、CyclicBarrier和Semaphore。

一.CountDownLatch

CountDownLatch 存在于java.util.cucurrent包下，字面意思为倒计数锁。

• countDownLatch这个类可以使一个线程等待其他线程各自执行完毕后再执行。

• 该功能是通过一个内部计数器的属性实现的 。每当一个线程执行完毕后，调用countDown()方法，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

1.1 CountDownLatch类中提供的构造方法：

//参数count为计数值
public CountDownLatch(int count) {
    
      };  

1.2 CountDownLatch类的重要方法：

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException {
    
     };   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
    
     };  
//将count值减1
public void countDown() {
    
     };  

1.3 CountDownLatch的示例代码：

一个对一个list中的对象，以pagesize为单位，开多个线程查数据库赋值处理，并得到相应结果。

public class Threads {
    
    
    public static void main(String[] args) throws Exception{
    
    
        //定义的一次查库的数量
        int pagesize = 3;
        //获取需要赋值的user集合
        List<User> list = getUserList();
        //计算需要并发的线程数
        int count = (list.size() + pagesize - 1) / pagesize;
        System.out.println("处理"+list.size()+"条数据，需要count:"+count+"个线程执行");
        List<User> newList = new ArrayList<>();
        //固定线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(count);
        CountDownLatch countDownLatch = new CountDownLatch(count);
        for (int i = 0; i < list.size(); i = i+pagesize) {
    
    
            TaskService ts = new TaskService(countDownLatch,list.subList(i,i+pagesize<=list.size()?i+pagesize:list.size()));
            //获取处理结果
            newList.addAll(threadPool.submit(ts).get());
        }
        try {
    
    
            //等待所有线程执行完毕
            countDownLatch.await();
        } catch (InterruptedException e) {
    
    
            System.out.println("InterruptedException exception"+e);
            Thread.currentThread().interrupt();
        } finally {
    
    
            threadPool.shutdown();
        }
       //输赋值后的结果
        for (User user: newList) {
    
    
            System.out.println(user.getName()+"_"+user.getAge());
        }
    }
    public static List<User> getUserList(){
    
    
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
    
    
            String name = "user"+i;
            list.add(new User(name));
        }

        return list;
    }
}

class TaskService implements Callable<List<User>> {
    
    
    private CountDownLatch countDownLatch;
    private List<User> userList;
    TaskService(CountDownLatch countDownLatch,List<User> userList){
    
    
        this.countDownLatch = countDownLatch;
        this.userList = userList;
    }


    @Override
    public List<User> call() throws Exception {
    
    
        int age = 1;
       try{
    
    
           //模拟查库，循环赋值
           for (User u: userList) {
    
    
               u.setAge(age++);
           }
       }finally {
    
    
           //调用方法计数器减1
           countDownLatch.countDown();
        }
        return userList;
    }
}

运行结果：

二.CyclicBarrier

从字面上的意思可以知道，这个类的中文意思是“循环栅栏”。大概的意思就是一个可循环利用的屏障。

它的作用就是会让所有线程都等待完成后才会继续下一步行动。

2.1 CyclicBarrier提供的构造方法

public CyclicBarrier(int parties)
public CyclicBarrier(int parties, Runnable barrierAction)

parties 是参与线程的个数

第二个构造方法有一个 Runnable 参数，这个参数的意思是最后一个到达线程要做的任务

1.2 CyclicBarrier类的重要方法：

public int await() throws InterruptedException, BrokenBarrierException
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException

解析：

• await()用来挂起当前线程，当线程调用 await() 表示自己已经到达barrier(栅栏)状态
• 第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

2.3 CyclicBarrier类的示例代码：

public class CyclicBarrierDemo {
    
    
    public static void main(String[] args) {
    
    
        int count = 3;
        //固定线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(count);
        CyclicBarrier cb = new CyclicBarrier(count, ()-> {
    
    
                System.out.println(Thread.currentThread().getName()+"所有线程到达栏栅状态！");
        });
        for (int i = 0; i < count; i++) {
    
    
            threadPool.submit(new CyclicBarrierTask(cb));
            Thread.sleep(1000L);
        }
        threadPool.shutdown();
    }
}

class CyclicBarrierTask implements Runnable{
    
    
    private CyclicBarrier cb;
    public CyclicBarrierTask(CyclicBarrier cb){
    
    
        this.cb = cb;
    }
    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName()+"开始执行...");
        try {
    
    
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName()+"到达栅栏状态！");
            cb.await();
            System.out.println(Thread.currentThread().getName()+"执行结束。。。");
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }
}

执行结果：

如果我们将上文实例代码的28行改造成

cb.await(1000L,TimeUnit.MILLISECONDS);

会看到等待了指定的时间发现线程还没有全部达到barrier，就抛出异常并继续执行后面的任务。

2.4 CyclicBarrier 使用场景

可以用于多线程计算数据，最后合并计算结果的场景。或者需要等各个线程的任务完成了，才能继续操作的任务，比如同时多张数据表入库。

2.5 CyclicBarrier 与CountDownLatch 区别

• CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
• CountDownLatch 参与的线程的职责是不一样的，有的在倒计时，有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。

三.Semaphore

Semaphore翻译成字面意思为 信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

3.1 Semaphore提供的构造方法

public Semaphore(int permits) {
    
              //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
    
        //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

2.3 Semaphore类的重要方法：

public void acquire() throws InterruptedException {
    
      }     //获取一个许可
public void acquire(int permits) throws InterruptedException {
    
     }    //获取permits个许可
public void release() {
    
     }          //释放一个许可
public void release(int permits) {
    
     }    //释放permits个许可

​ acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。

release()用来释放许可。注意，在释放许可之前，必须先获获得许可。

这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

public boolean tryAcquire() {
    
     };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
    
     };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) {
    
     }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException {
    
     }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

另外还可以通过availablePermits()方法得到可用的许可数目。

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现：

2.4 Semaphore类的示例代码：

ublic class Test {
    
    
    public static void main(String[] args) {
    
    
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
     
    static class Worker extends Thread{
    
    
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
    
    
            this.num = num;
            this.semaphore = semaphore;
        }
         
        @Override
        public void run() {
    
    
            try {
    
    
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

总结：

1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。