Latch设计模式

什么是Latch设计模式？

    做程序员是个苦差事，并不像外人看到的那么光鲜，加班熬夜是家常便饭的事，Alex在结束了连续一个月的加班之后决定约上几个同为程序员的好朋友（jack,Gavin,Dillon）打算在周末的时候放松一下，他们相约在周六的早上十点在城市广场北口见面，然后一同前往郊区的“同心湖”垂钓、烧烤，最后登上本市的最高建筑‘汇聚塔’，计划了出游路线之后，每个人或乘坐公交，或搭乘地铁，总之他们都会在城市广场北口相会，然后统一去做同一件事，那就是一起前往“同心湖”。

    诸如此类的情形在我们的日常生活中也是屡见不鲜，比如若干线程并发执行某个特定的任务，然后等到所有的子任务都执行结束之后再统一汇总，比如用户想要查询自己三年以来银行账号的流水，为了保证运行数据库的数据量在一个恒定的范围内，通常数据只会保存一年的记录，其他的历史记录或被备份到磁盘，或者被存储于hive数据仓库，或者被转存至备份数据库之中，总之想要三年的流水记录，需要若干个渠道的查询才可以汇齐。如果一个线程负责执行这样的任务，则需要经历若干次的查询最后汇总返回给用户，很明显这样的操作性能低下，用户体验差，如果我们将每一个渠道的查询交给一个线程或者若干个线程去查询，然后统一汇总，那么性能会提高跟多，响应时间也会缩短不少。

    再回到程序员出游的例子，每个程序员到达城市广场北口的时间不一定，同样到达广场的方式也不尽相同，但是他们都会陆续到达汇集的地点，假设Jack由于堵车迟迟未到，其他三个人只能一直等待，直到Jack到达城市广场北口才能一同前往。
    Latch(阀门)设计模式，该模式指定了一个屏障，只有所有的条件都达到满足的时候，门阀才能打开。

 

CountDownLatch程序实现

package MutilThreadModel.LatchModel;
import java.util.concurrent.TimeUnit;
/**
 * Created by JYM on 2019/1/15
 * 无限等待的Latch
 * */
public abstract class Latch
{
    //用于控制多少个线程完成任务时才能打开阀门
    protected int limit;

    //通过构造函数传入limit
    public Latch(int limit)
    {
        this.limit = limit;
    }

    //该方法会使得当前线程一直等待，直到所有的线程都完成工作，被阻塞的线程是允许被中断的
    public abstract void await() throws InterruptedException;

    //当任务线程完成工作之后调用该方法使得计数器减一
    public abstract void countDown();

    //获取当前还有多少个线程没有完成任务
    public abstract int getUnarrived();

    //增加可超时的抽象方法
    public abstract void await(TimeUnit unit,long time) throws InterruptedException,WaitTimeoutException;
}
/**
 * 子任务数量达到limit的时候，门阀才能打开，await()方法用于等待所有的子任务完成，如果到达数量未达到limit的时候，将会无限等待
 * 下去，当子任务完成的时候调用countDown()方法使计数器减少一个，表明我已经完成任务了，getUnarrived()方法主要用于查询当前有
 * 多少个子任务还未结束。
 * */

无限等待CountDownLatch的实现

package MutilThreadModel.LatchModel;
import java.util.concurrent.TimeUnit;
/**
 * Created by JYM on 2019/1/15
 * 实现一个无限制等待门阀打开的Latch实现，当limit>0时调用await方法的线程
 * 将会进入无限的等待。
 * */
public class CountDownLatch extends Latch
{
    public CountDownLatch(int limit)
    {
        super(limit);
    }

    @Override
    public void await() throws InterruptedException
    {
        synchronized (this)
        {
            //当limit>0,当前线程进入阻塞状态
            while (limit>0)
            {
                this.wait();
            }
        }
    }

    @Override
    public void countDown()
    {
        synchronized (this)
        {
            if (limit <= 0)
            {
                throw new IllegalStateException("all of task already arrived");
            }

            //使limit减一，并且通知阻塞线程
            limit--;
            this.notifyAll();
        }
    }

    @Override
    public int getUnarrived()
    {
        //返回有多少线程还未完成任务
        return limit;
    }

    @Override
    public void await(TimeUnit unit, long time) throws InterruptedException,WaitTimeoutException
    {
        if (time<0)
        {
            throw new IllegalArgumentException(" The time is invalid ");
        }
        long remainingNanos = unit.toNanos(time);     //将time转换为纳秒
        //等待任务将在endNanos纳秒后超时
        final long endNanos = System.nanoTime()+remainingNanos;

        synchronized (this)
        {
            while (limit>0)
            {
                //如果超时则抛出WaitTimeoutException异常
                if (TimeUnit.NANOSECONDS.toMillis(remainingNanos) <= 0)
                {
                    throw new WaitTimeoutException(" The wait time over specify time.");
                }

                //等待remainingNanos,在等待的过程中有可能会被中断，需要重新计算remainingNanos
                this.wait(TimeUnit.NANOSECONDS.toMillis(remainingNanos));
                remainingNanos = endNanos-System.nanoTime();
            }
        }
    }

    /*
    * 为了方便计算，我们将所有的时间单都换算成了纳秒，但是Object的wait方法只能够接受纳秒，因此该方法还涉及了时间
    * 的换算，另外如果等待剩余时间不足1毫秒，那么将会抛出WaitTimeoutException异常通知等待者。
    * */
}
/**
 * 在上述代码中，await()方法不断判断limit的数量，大于0时门阀将不能打开，需要持续等待直到limit数量为0为止；
 * countDown()方法调用之后会导致limit--操作，并且通知wait中的线程再次判断limit的值是否等于0，当limit被减少
 * 到了0以下，则抛出状态非法的异常；getUnarrived()获取当前还有多少个子任务未完成，这个返回值并不一定就是准确
 * 的，在多线程的情况下，某个线程在获得Unarrived任务数量并且返回之后，有可能limit又被减少，因此getUnarrived是一个评估值。
 * */

 

package MutilThreadModel.LatchModel;
/**
 * Created by JYM on 2019/1/15
 * */
//当子任务线程执行超时的时候将会抛出该异常
public class WaitTimeoutException extends Exception
{
    public WaitTimeoutException(String message)
    {
        super(message);
    }
}

 

程序测试：

package MutilThreadModel.LatchModel;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

/**
 * Created by JYM on 2019/1/15
 * 测试程序
 * */

/*
* 程序员旅游线程
* */
public class ProgrammerTravel extends Thread
{
    //门阀
    private final Latch latch;
    //程序员
    private final String programmer;

    //交通工具
    private final String transportation;

    //通过构造函数传入latch,programmer,transportation
    public ProgrammerTravel(Latch latch,String programmer,String transportation)
    {
        this.latch = latch;
        this.programmer = programmer;
        this.transportation = transportation;
    }

    @Override
    public void run() {
        System.out.println(programmer+" start take the transportation ["+transportation+"]");
        try{
            //程序员乘坐交通工具花费在路上的时间(使用随机数字模拟)
            TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(10));
        }catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println(programmer+" arrived by "+transportation);
        //完成任务时使计数器减一
        latch.countDown();
    }
    /*
    * ProgrammerTravel继承自Thread代表程序员，需要三个构造函数，第一个是前文中设计的latch(门阀)，第二个是程序员的名称，比如
    * 前文中的Jack、Gavin等，第三个参数则表示他们所搭乘的交通工具。
    * TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(10))子句在run方法中模拟每个人到达目的地所花费的时间，
    * 当他们分别到达目的地的时候，需要执行latch.countDown(),使计数器减少一个以标明自己已到达。
    * */

//    public static void main(String[] args) throws InterruptedException
//    {
//        //定义Latch,limit为4
//        Latch latch = new CountDownLatch(4);
//        new ProgrammerTravel(latch,"Alex","Bus").start();
//        new ProgrammerTravel(latch,"Gavin","Walking").start();
//        new ProgrammerTravel(latch,"Jack","Subway").start();
//        new ProgrammerTravel(latch,"Dillon","Bicycle").start();
//        //当前线程（main线程会进入阻塞，直到四个程序员全部都到达目的地）
//        latch.await();
//        System.out.println("== all of programmer arrived ==");
//    }
    public static void main(String[] args) throws InterruptedException
    {
        Latch latch = new CountDownLatch(4);
        new ProgrammerTravel(latch,"Alex","Bus").start();
        new ProgrammerTravel(latch,"Gavin","Walking").start();
        new ProgrammerTravel(latch,"Jack","Subway").start();
        new ProgrammerTravel(latch,"Dillon","Bicycle").start();
        try
        {
            latch.await(TimeUnit.SECONDS,5);
            System.out.println("== all of programmer arrived ==");
        }catch (WaitTimeoutException e)
        {
            e.printStackTrace();
        }
    }
}