java.util.concurrent中的常用组件

一. CountDownLatch

        一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

CountDownLatch的主要方法：

方法名称	方法作用
public CountDownLatch(int count)	构造器参数指定了计数的次数，即有几个独立的任务
public void CountDown()	当前线程调用此方法，计数减一，即其中一个任务完成
public void await()	当前线程调用此方法会一直被阻塞，直到计数为0，即所有子任务都完成了。

package com.wbl.test.thread.countDownLatch;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

/**
 * Created with Simple_love
 * Date: 2016/3/19.
 * Time: 16:06
 */
public class CountDownLatchDemo {
 13:     final static SimpleDateFormat                         sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public static void main(String[] args) throws InterruptedException {
                CountDownLatch countDownLatch = new CountDownLatch(2);    //两个工人协同工作
                Worker worker1 = new Worker("work1",5000,countDownLatch);
                Worker worker2 = new Worker("work2",8000,countDownLatch);
                worker1.start();
                worker2.start();
                countDownLatch.await();   //等待所有的工人结束
                System.out.println("all work done at " + sdf.format(new Date()));
        }

        static class Worker extends Thread{
                String name;
                int workTime;
                CountDownLatch countDownLatch;
                public Worker(String name,int workTime,CountDownLatch countDownLatch){
                        this.name = name;
                        this.workTime = workTime;
                        this.countDownLatch = countDownLatch;
                }

                public void doWork(){
                        try {
                                Thread.sleep(workTime);
                        }catch (InterruptedException e){
                                e.printStackTrace();
                        }
                }

                @Override
                public void run() {
                        System.out.println("Worker " + name + " do work begin at " + sdf.format(new Date()));
                        doWork();//工作了
                       System.out.println("Worker "+name+" do work complete at "+sdf.format(new Date()));
                       countDownLatch.countDown();//工人完成工作，计数器减一

                }
        }
}

CountDownLatch被设计为只触发一次，计数值不能被重置。一旦计数器的值初始后，唯一可以修改它的方法就是之前用的 countDown() 方法。当计数器到达0时， 全部调用 await() 方法会立刻返回，接下来任何countDown() 方法的调用都将不会造成任何影响。

二. CyclicBarrier

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

CyclicBarrier的主要方法

方法名称	方法作用
public CyclicBarrier(int):	构造器参数指定线程的个数，即有几个互相等待的任务
public void CyclicBarrier(int,Runnable):	当一组的线程全都到达某个状态后，开始执行Runnable对象
public void await()	某个线程到达barrier状态

CyclicBarrier的应用场景：在某种需求中，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择CyclicBarrier了。

实例分析：我们需要统计全国的业务数据。其中各省的数据库是独立的，也就是说按省分库。并且统计的数据量很大，统计过程也比较慢。为了提高性能，快速计算。我们采取并发的方式，多个线程同时计算各省数据，最后再汇总统计。在这里CyclicBarrier就非常有用。

/**
* 各省数据独立，分库存偖。为了提高计算性能，统计时采用每个省开一个线程先计算单省结果，最后汇总。
*
* @author guangbo email:weigbo@163.com
*
*/
public class Total {

   // private ConcurrentHashMap result = new ConcurrentHashMap();

   public static void main(String[] args) {
       TotalService totalService = new TotalServiceImpl();
        CyclicBarrier barrier = new CyclicBarrier(5,
                new TotalTask(totalService));

        // 实际系统是查出所有省编码code的列表，然后循环，每个code生成一个线程。
        new BillTask(new BillServiceImpl(), barrier, "北京").start();
        new BillTask(new BillServiceImpl(), barrier, "上海").start();
        new BillTask(new BillServiceImpl(), barrier, "广西").start();
        new BillTask(new BillServiceImpl(), barrier, "四川").start();
        new BillTask(new BillServiceImpl(), barrier, "黑龙江").start();
   }
}

/**
 * 主任务：汇总任务
 */
class TotalTask implements Runnable {
    private TotalService totalService;

    TotalTask(TotalService totalService) {
        this.totalService = totalService;
    }

    public void run() {
        // 读取内存中各省的数据汇总，过程略。
        totalService.count();
        System.out.println("=======================================");
        System.out.println("开始全国汇总");
    }
}

/**
 * 子任务：计费任务
 */
class BillTask extends Thread {
    // 计费服务
    private BillService billService;
    private CyclicBarrier barrier;
    // 代码，按省代码分类，各省数据库独立。
    private String code;

    BillTask(BillService billService, CyclicBarrier barrier, String code) {
        this.billService = billService;
       this.barrier = barrier;
        this.code = code;
    }

    public void run() {
        System.out.println("开始计算--" + code + "省--数据！");
        billService.bill(code);
        // 把bill方法结果存入内存，如ConcurrentHashMap,vector等,代码略
        System.out.println(code + "省已经计算完成,并通知汇总Service！");
        try {
            // 通知barrier已经完成
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

}

 

CountDownLatch和CyclicBarrier的区别

CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

三. DelayQueue

DelayQueue类的主要作用：是一个无界的BlockingQueue，用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。注意：不能将null元素放置到这种队列中。

Delayed，一种混合风格的接口，用来标记那些应该在给定延迟时间之后执行的对象。此接口的实现必须定义一个 compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。

(1) 实例场景

模拟一个考试的日子，考试时间为120分钟，30分钟后才可交卷，当时间到了，或学生都交完卷了考试结束。

这个场景中几个点需要注意：

1. 考试时间为120分钟，30分钟后才可交卷，初始化考生完成试卷时间最小应为30分钟
2. 对于能够在120分钟内交卷的考生，如何实现这些考生交卷
3. 对于120分钟内没有完成考试的考生，在120分钟考试时间到后需要让他们强制交卷
4. 在所有的考生都交完卷后，需要将控制线程关闭

实现思想：用DelayQueue存储考生（Student类），每一个考生都有自己的名字和完成试卷的时间，Teacher线程对DelayQueue进行监控，收取完成试卷小于120分钟的学生的试卷。当考试时间120分钟到时，先关闭Teacher线程，然后强制DelayQueue中还存在的考生交卷。每一个考生交卷都会进行一次countDownLatch.countDown()，当countDownLatch.await()不再阻塞说明所有考生都交完卷了，而后结束考试。

package com.wbl.test.thread.delayQueue;

import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * Created with Simple_love
 * Date: 2016/3/19.
 * Time: 14:29
 */
public class Exam {
        public static void main(String[] args) throws InterruptedException {
                int count = 20;
                DelayQueue<Student> students = new DelayQueue<>();
                Random random = new Random();
                CountDownLatch countDownLatch = new CountDownLatch(count+1);
                for (int i = 1; i <= 20; i++)
                        students.add(new Student("student" + i,30+random.nextInt(120),countDownLatch));
                Thread teacherThread = new Thread(new Teacher(students));
                students.add(new EndExam(students,120,countDownLatch,teacherThread));
                teacherThread.start();
                countDownLatch.await();
                System.out.println(" 考试时间到，全部交卷！");
        }
}
class Student implements Runnable,Delayed{
        private String name;
        private long workTime; //考试时间
        private long submitTime; //交卷时间
        private boolean isForce = false;
        private CountDownLatch countDownLatch;

        public Student() {
        }

        public Student(String name, long workTime,CountDownLatch countDownLatch) {
                this.name = name;
                this.workTime = workTime;
                this.submitTime = TimeUnit.NANOSECONDS.convert(workTime,TimeUnit.NANOSECONDS) + System.nanoTime();
                this.countDownLatch = countDownLatch;
        }

        @Override
        public long getDelay(TimeUnit unit) {
                return unit.convert(submitTime-System.nanoTime(),TimeUnit.NANOSECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
                if (o == null || ! (o instanceof Student))
                        return 1;
                if (o == this)
                        return 0;
                Student temp = (Student)o;
                if (this.workTime > temp.workTime)
                        return 1;
                else if (this.workTime == temp.workTime)
                        return 0;
                else
                        return -1;
        }

        @Override
        public void run() {
                if (isForce) {
                        System.out.println(name + " 交卷, 希望用时" + workTime + "分钟"+" ,实际用时 120分钟" );
                }else {
                        System.out.println(name + " 交卷, 希望用时" + workTime + "分钟"+" ,实际用时 "+workTime +" 分钟");
                }
                countDownLatch.countDown();
        }

        public boolean isForce() {
                return isForce;
        }

        public void setForce(boolean isForce) {
                this.isForce = isForce;
        }
}

class Teacher implements Runnable{

        private DelayQueue<Student> students;

        public Teacher(DelayQueue<Student> students) {
                this.students = students;
        }

        @Override
        public void run() {
                try {
                        System.out.println("exam start");
                        while (!Thread.interrupted())
                                students.take().run();
                }catch (InterruptedException e){
                        System.out.println("exam end");
                }
        }
}

class EndExam extends Student{
        private DelayQueue<Student> students;
        private CountDownLatch countDownLatch;
        private Thread teacher;

        public EndExam(DelayQueue<Student> students,long workTime,CountDownLatch countDownLatch,Thread teacher){
                super("强制收卷",workTime,countDownLatch);
                this.students = students;
                this.countDownLatch = countDownLatch;
                this.teacher = teacher;
        }

        @Override
        public void run() {
                teacher.interrupt();
                System.out.println("强制收卷");
                Student temp;
                for (Iterator<Student> iterator = students.iterator();iterator.hasNext();){
                        temp = iterator.next();
                        temp.setForce(true);
                        temp.run();
                }
                countDownLatch.countDown();
        }
}

四. Semaphore

Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

public class SemaphoreTest {

     public static void main(String[] args) {
        // 线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        // 只能5个线程同时访问
        final Semaphore semp = new Semaphore(5);
        // 模拟20个客户端访问
        for (int index = 0; index < 20; index++) {
            final int NO = index;
            Runnable run = new Runnable() {
                public void run() {
                    try {
                        // 获取许可
                        semp.acquire();
                        System.out.println("Accessing: " + NO);
                        Thread.sleep((long) (Math.random() * 10000));
                        // 访问完后，释放 ，如果屏蔽下面的语句，则在控制台只能打印5条记录，之后线程一直阻塞
                        semp.release();
                    } catch (InterruptedException e) {
                    }
                }
            };
            exec.execute(run);
        }
        // 退出线程池
        exec.shutdown();
    }
}