java提高篇—主线程等待分支线程执行后才执行的方法

最近打算去面试，查找一些面试题，看到京东的面试题中题，将查到的进行了总结，希望能对面试的同行有帮助。

主线程等待分支线程执行后才执行方法有以下几种：

1. 使用countdownlatch

解释：CountDownLatch是一个同步辅助类，通过它可以完成类似于阻塞当前线程的功能，即：一个线程或多个线程一直等待，直到其他线程执行的操作完成。
缺点：事先必须知道要多少个线程，如果不知道有多少个线程，那么这个方法就没有办法。
优点：速度比较快。

2. 使用join

解释：调用join方法，等待线程t执行完毕。
缺点：效率比较低。
优点：这个会使得线程进行排序。可以按照特定的顺序进行执行。

3. 使用sleep

缺点：通过睡眠来满足条件，只要睡眠的时间足够大就可以达到这个效果。但是睡眠的时间不可估计。
优点：使用简单。

4. 使用Thread.activeCount()!=1这个方法来进行判断，现在正在存活的线程个数。

解释：该方法返回活动线程的当前线程的线程组中的数量.
缺点：如果有本来这个系统就已经调用了多个线程，所以这个系统内就会有多个线程，判断存活线程数量可能就不太准确。而且如果存在时间任务线程，可能没有关闭，那么就一直会等待。
优点：可以不用管理有多少个线程，直到所有的线程都执行完毕才会结束。

5. 使用cyclicbarrier来进行等待

解释：栅栏允许两个或者多个线程在某个集合点同步。当一个线程到达集合点时，它将调用await()方法等待其它的线程。线程调用await()方法后，CyclicBarrier将阻塞这个线程并将它置入休眠状态等待其它线程的到来。等最后一个线程调用await()方法时，CyclicBarrier将唤醒所有等待的线程然后这些线程将继续执行。CyclicBarrier可以传入另一个Runnable对象作为初始化参数。当所有的线程都到达集合点后，CyclicBarrier类将Runnable对象作为线程执行。
缺点：事先必须知道有多少个线程，如果不知道有多少个线程也没有办法执行。
优点：可以使所有的方法执行到某一步后都暂停，等待所有的都到达这一步之后再继续执行。

以下石具体的代码：

package cn.test.main;  

import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.CyclicBarrier;  

public class MainThread { 
    static CountDownLatch countDownLatch = new CountDownLatch(10);  
    static CyclicBarrier barrier = new CyclicBarrier(11);  

    public static void main(String[] args) throws Exception {  

        long start = System.currentTimeMillis();  

        countDownLatch();  
        //join();  
        //activeCount();  
        //cyclicbarrier();  
        //sleep();  

        long end = System.currentTimeMillis();  
        System.out.println(end - start);  

    }  

    private static void sleep() {  

        for(int i =0;i<10;i++){  
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                }  
            }).start();  
        }  
        try {  
            Thread.sleep(10000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  

    private static void cyclicbarrier() throws InterruptedException, BrokenBarrierException {  
        for(int i =0;i<10;i++){  
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                    try {  
                        barrier.await();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    } catch (BrokenBarrierException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }).start();  
        }  
        barrier.await();  
    }  

    private static void activeCount() {  
        for(int i =0;i<10;i++){  
            new Thread(new Runnable() {  

                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                }  
            }).start();  
        }  
        while(Thread.activeCount()!=1){  

        }  
    }  

    private static void join() throws InterruptedException {  
        for(int i =0;i<10;i++){  

            Thread thread = new Thread(new Runnable() {  

                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                }  
            });  
            thread.start();  
            thread.join();  
        }  
    }  

    private static void countDownLatch() throws InterruptedException {  
        for(int i = 0;i<10;i++)  
        new Thread(new Runnable() {  

            @Override  
            public void run() {  
                System.out.println(Thread.currentThread().getName());  
                countDownLatch.countDown();  
            }  
        }).start();  
        countDownLatch.await();  
    }      
}