Java并发编程 闭锁Latch

本文整理自《Java并发编程实战》一书。

闭锁（Latch）是一种同步工具类，可以延迟线程的进度直到其到达终止状态。闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开状态。闭锁可以用来确保某些活动直到其他活动都完成后才继续执行，例如：

※ 确保某个服务在其依赖的所有其他服务都已经启动之后才启动。每个服务都有一个相关的二元闭锁。当启动服务S时，将首先在S依赖的其他服务的闭锁上等待，在所有依赖的服务都启动后会释放闭锁S，这样其他依赖S的服务才能继续执行。

※ 等待直到某个操作的所有参与者（例如，在多玩家游戏中的所有玩家）都就绪再继续执行。在这种情况下，当所有玩家都准备就绪时，闭锁将到达结束状态。Dota2的玩家加载时就是采用这种闭锁思想，必须所有玩家就绪才会结束loading画面。

java.util.concurrent. CountDownLatch 是一种灵活的闭锁实现，可以在上述各种情况中使用，它可以使一个或者多个线程等待一组事件发生。闭锁状态包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件数量。countDown方法递减计数器，表示有一个事件已经发生了，而await方法等待计数器达到零，这表示所有需要等待的事件都已经发生。如果计数器的值非零，那么await会一直阻塞直到计数器为零，或者等待中的线程中断，或者超时。

如下面的TestLatch中给出了闭锁的两种常见用法。TestLatch创建一定数量的线程，利用它们并发地执行指定的任务。它使用两个闭锁，分别是“起始门（startGate）”和“结束门（endGate）”。起始门计数器的初始值为1，而结束门计数器的初始值为工作线程的数量。每个工作线程首先要做的事就是在启动门上等待，从而确保所有线程都就绪才开始执行。而每个线程要做的最后一件事情就是将调用结束门的countDown方法减1，这能使主线程高效地等待直到所有工作线程都执行完成，因此可以统计所消耗的时间。

public class TestLatch
{

    public long timeTasks(int nThreads, final Runnable task)
        throws InterruptedException
    {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);

        for (int i = 0; i < nThreads; i++ )
        {
            Thread t = new Thread()
            {
                public void run()
                {
                    try
                    {
                        startGate.await();
                        task.run();
                    }
                    catch (InterruptedException e)
                    {//ignored
                    }
                    finally
                    {
                        endGate.countDown();
                    }
                }
            };
            t.start();
        }
        long start = System.nanoTime();
        startGate.countDown();
        endGate.await();
        long end = System.nanoTime();
        return end - start;
    }
}

此外，FutureTask也是一种闭锁。

    public static void future()
    {

        ExecutorService executor = Executors.newFixedThreadPool(10);
        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>()
        {
            public String call()
            {
                //真正的任务在这里执行，这里的返回值类型为String，可以为任意类型  
                return "simple";
            }
        });
        executor.execute(futureTask);
        try
        {
            //取得结果，同时设置超时执行时间为5秒。同样可以用future.get()，不设置执行超时时间取得结果  
            String result = futureTask.get(5000, TimeUnit.MILLISECONDS);
            //业务处理……
            System.out.println(result);
        }
        catch (InterruptedException e)
        {
            Thread.currentThread().interrupt();
        }
        catch (ExecutionException e)
        {
            //skip
        }
        catch (TimeoutException e)
        {
            //skip
        }
        finally
        {
            executor.shutdown();
        }
    }