JAVA多线程下的同步问题-等所有线程执行完在执行下面的操作

JAVA同步工具类CountDownLatch的用法

提示：在我们进行JAVA多线程编程时，有时我们想要等到所有新开辟的线程执行完毕后再执行下面的操作，又或者是需要等到异步操作的结果。那么，此时我们就需要对当前的“主线程”进行阻塞。Java的同步工具类CountDownLatch给我们提供了一个不错的解决方案。

---

---

一、概念

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量：CountDownLatch c = new CountDownLatch(线程数量)。当每一个线程完成自己任务后，计数器的值就会减一：c.countDown()。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务：**boolean wait = latch.await(30, TimeUnit.SECONDS)**表示等待30秒后计数器的值还没变为0的话就会继续执行。

二、工具类常用方法

1.await()

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

2.countDown()

//将count值减1
public void countDown() { }; 

三、完整例子

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Dell
 *
 */
public class CountDownLatchTest {

	public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);
        System.out.println("主线程开始执行…… ……");
        //第一个子线程执行
        //ExecutorServiceJava提供的线程池方法
        ExecutorService es1 = Executors.newSingleThreadExecutor();
        es1.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    System.out.println("子线程："+Thread.currentThread().getName()+"执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            }
        });
        es1.shutdown();

        //第二个子线程执行
        ExecutorService es2 = Executors.newSingleThreadExecutor();
        es2.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程："+Thread.currentThread().getName()+"执行");
                latch.countDown();
            }
        });
        es2.shutdown();
        System.out.println("等待两个线程执行完毕…… ……");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("两个子线程都执行完毕，继续执行主线程");
    }
}

---

总结

在实际开发中的使用场景

1. 实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。
2. 开始执行前等待N个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统都已经启动和运行了。
3. 死锁检测：一个非常方便的使用场景是你用N个线程去访问共享资源，在每个测试阶段线程数量不同，并尝试产生死锁。