线程等待的四种方式-join/future/countDownLatch/cylicBarrier实现

绝地灬酷狼 2022-04-23 04:20 55阅读 0赞

场景如下：一共三个线程a,b,c,其中c需要用到a,b,执行的结果,应该怎么处理?

### 1）CountDownLatch，主线程中调用await方法，每个线程调用countdown ###

上面两种方法需要分别调用多次join或future的get方法,不太好,有一种方法是使用CountDownLatch类  
认知CountDownLatch的方法:  
await():阻塞主线程,直到countDownLatch的计数器减少到0的位置,  
countDown:将当前的计数器减1  
getCount:返回当前的数  
思路如下:让a,b线程使用CountDowmLatch,然后执行countDownLatch的await方法  
主类:  
    public static void main(String\[\] args) \{  
        CountDownLatch countDownLaunch = new CountDownLatch(5);  
        for(int i=1;i<6;i++)\{  
            ThreadWithCountDownLatch threadWithCountDownLatch = new ThreadWithCountDownLatch(i\*1000L,countDownLaunch,"THREAD"+i);  
            Thread thread = new Thread(threadWithCountDownLatch);  
            thread.start();  
        \}  
        mainThreadWork();  
        try \{  
            countDownLaunch.await();//下面的代码要等待所有的countDown的计数器为零再执行  
        \} catch (InterruptedException e) \{  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        \}

System.out.println("all done");      
    \}  
线程类:  
public class ThreadWithCountDownLatch implements Runnable\{  
    long time;  
    CountDownLatch countDownLatch;  
    String name;  
    public ThreadWithCountDownLatch(long time,CountDownLatch countDownLatch,String name)\{  
        this.time=time;  
        this.countDownLatch = countDownLatch;  
        this.name=name;  
    \}  
    @Override  
    public void run() \{  
        try \{  
            System.out.println(name+" start");  
            work(time);  
            System.out.println(name+" end");  
        \} catch (InterruptedException e) \{  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        \}finally\{  
            countDownLatch.countDown();  
        \}  
    \}

private void work(long time2) throws InterruptedException \{  
        Thread.sleep(time2);      
    \}  
\}

### 2）CyclicBarrier-每个线程中调用await，调用达到次数再一起放行 ###

调用栅栏(计数器为5)的await,相当于告诉栅栏已经有一个线程到达栅栏,同时线程本身不再继续执行;当cyclicBarrier的await方法调用5次时,所有线程继续执行,同时触发栅栏的run方法  
主类:  
    public static void main(String\[\] args) \{  
        CyclicBarrier cylicBarrier = new CyclicBarrier(5,new Runnable() \{  
            //栅栏动作,在计数器为零的时候执行  
            @Override  
            public void run() \{//栅栏的await方法执行五次后会调用此处  
                // TODO Auto-generated method stub  
                System.out.println("all work done");  
            \}  
        \});  
        ExecutorService pool = Executors.newFixedThreadPool(5);  
        for(int i=1;i<6;i++)\{  
            pool.submit(new ThreadWithCyclicBarrier(i,cylicBarrier));  
        \}  
        pool.shutdown();  
        System.out.println("last ");      
    \}  
线程类:  
public class ThreadWithCyclicBarrier  implements Runnable\{  
    int id;  
    CyclicBarrier cyclicBarrier;  
      
    public ThreadWithCyclicBarrier(int id,CyclicBarrier cyclicBarrier)\{  
        this.id = id;  
        this.cyclicBarrier=cyclicBarrier;  
    \}  
    @Override  
    public void run() \{  
        System.out.println("thread"+id+" start");  
        try \{  
            cyclicBarrier.await();//栅栏计数值为零后会继续执行  
            Thread.sleep(1000L);  
        \} catch (InterruptedException e) \{  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        \} catch (BrokenBarrierException e) \{  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        \}  
        System.out.println("thread"+id+" end");  
    \}  
\}

### 3)join方法实现 ###

对a,b使用a.join()和b.join();    然后下面使用c.start()  
SubTThread subthread = new SubTThread("subthread");  
        SubTThread subthread2 = new SubTThread("subthread2");  
        SubTThread subthread3 = new SubTThread("subthread3");  
        Thread thread = new Thread(subthread);  
        Thread thread2 = new Thread(subthread2);  
        Thread thread3 = new Thread(subthread3);  
        thread.start();  
        thread2.start();  
        mainThreadWork();  
        System.out.println("wait subthread done");  
        try \{  
            thread.join();  
            thread2.join();//当thread和thread2的run方法执行完毕后才会继续下面的代码  
        \} catch (InterruptedException e) \{  
            e.printStackTrace();  
        \}  
        thread3.start();  
        System.out.println("all work done");

### 4）线程池submit线程返回Future,并调用future的get方法 ###

使用线程池,线程池submit线程返回Future,并调用future的get方法.则get方法下的代码都需要等待调用了get方法的线程完全执行后再执行  
    public static void main(String\[\] args) \{  
        ExecutorService pool = Executors.newFixedThreadPool(3);  
          
        SubTThreadByRun subthread = new SubTThreadByRun("subthread");  
        SubTThreadByRun subthread2 = new SubTThreadByRun("subthread2");          
        Thread thread = new Thread(subthread);  
        Thread thread2 = new Thread(subthread2);  
        ThreadByCall threadByCall = new ThreadByCall("call1");  
          
        Future future1 = pool.submit(thread);  
        Future future2 = pool.submit(thread2);  
        Future future3 = pool.submit(threadByCall);  
        mainThreadWork();  
        try \{  
            future1.get();  
            future2.get();  
            String str = (String) future3.get();//下面的代码需要等待thread1/thread2和threadByCall 执行完毕后执行下面的代码  
            System.out.println("得到结果:"+str);  
        \} catch (InterruptedException e) \{  
            e.printStackTrace();  
        \} catch (ExecutionException e) \{  
            e.printStackTrace();  
        \}

SubTThreadByRun subthread3 = new SubTThreadByRun("subthread3");          
Thread thread3 = new Thread(subthread3);  
        thread3.start();  
        System.out.println("all work done");  
        pool.shutdown();//关闭线程池  
    \}

### 四种实现方式比较 ###

join--适用于少量线程  
线程池submit+future.get--适用于实际使用的线程数量不定，且所有线程执行完毕  
CountDownLatch--设置线程数，每个线程结尾使用countDown()方法减值，主线程中调用await方法来阻塞，当数据减为0时，主线程继续执行，适用于实际使用线程数量固定  
栅栏--多个线程都执行到某个点暂停，然后再一起开始，并且增加栅栏的run方法  
new CyclicBarrier(5,new Runnable()）;每个线程执行到CyclicBarrier.await方法，线程会暂停，当await方法执行5次时，所有线程继续运行，并且执行cyclicBarrier的runner的run方法