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();  
    }      
}  

你可能感兴趣的:(java,线程)