java中等待一些线程执行完之后，再去执行别的方法（后者需要使用前者返回的结果）

最新推荐文章于 2024-04-17 14:17:25 发布

转载最新推荐文章于 2024-04-17 14:17:25 发布 · 6.1k 阅读

android 同时被 2 个专栏收录

85 篇文章

订阅专栏

java js jquery

26 篇文章

订阅专栏

本文介绍了Java中三种实现多线程同步的方法：Thread的join()方法、CountDownLatch及CyclicBarrier，通过示例代码详细解释了它们如何确保一组线程执行完毕后再执行后续操作。

一、使用Thread的join()等待所有的子线程执行完毕，主线程在执行，thread.join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

/**  
 *   
 * 处理一个业务逻辑的场景：当一组线程都执行完之后，在执行别的线程（后者要使用前者返回的结果）  
 * @author Administrator  
 *  
 */  
public class ThreadDemo {  
  
    public static void main(String[] args) throws InterruptedException {  
        Vector<Thread> vectors=new Vector<Thread>();  
        //启用5个线程  
        for(int i=1;i<=5;i++){  
            Thread childrenThread=new Thread(new Runnable(){  
                 public void run(){  
                     try {  
                        Thread.sleep(1000);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                     System.out.println("子线程执行！");  
                       
                 }  
            });  
            vectors.add(childrenThread);  
            childrenThread.start();  
        }  
        //主线程  
        for(Thread thread : vectors){  
            thread.join(); //使用join来保证childrenThread的5个线程都执行完后，才执行主线程  
        }  
        System.out.println("主线程执行！");  
  
    }  
  
}

二、下面结合这个问题我介绍一些并发包里非常有用的并发工具类，等待多线程完成的CountDownLatch

在这里说明一点，countDownLatch不可能重新初始化或者修改CountDownLatch对象内部计数器的值，一个线程调用countdown方法happen-before另外一个线程调用await方法

/**  
 *   
 * 处理一个业务逻辑的场景：当一组线程都执行完之后，在执行别的线程（后者要使用前者返回的结果）  
 * @author Administrator  
 *  
 */  
public class ThreadDemo2 {  
  
    public static void main(String[] args) throws InterruptedException {  
        final CountDownLatch latch= new CountDownLatch(5);//使用java并发库concurrent  
        //启用5个线程  
        for(int i=1;i<=5;i++){  
            new Thread(new Runnable(){  
                 public void run(){  
                     try {  
                        Thread.sleep(1000);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                     System.out.println("子线程执行！");  
                     latch.countDown();//让latch中的数值减一  
                       
                 }  
            }).start();  
              
        }  
        //主线程  
        latch.await();//阻塞当前线程直到latch中数值为零才执行  
        System.out.println("主线程执行！");  
  
    }  
  
}

三、同步屏障CyclicBarrier

/**  
 *   
 * 处理一个业务逻辑的场景：当一组线程都执行完之后，在执行别的线程（后者要使用前者返回的结果）  
 * @author Administrator  
 *  
 */  
public class ThreadDemo3 {  
  
    public static void main(String[] args) throws Exception {  
        final CyclicBarrier barrier=new CyclicBarrier(5);  
        //启用5个线程  
        for(int i=1;i<=5;i++){  
            new Thread(new Runnable(){  
                 public void run(){  
                     try {  
                        Thread.sleep(1000);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                     System.out.println("子线程执行！");  
                     try {  
                        barrier.await();//到达屏障  
                    } catch (InterruptedException | BrokenBarrierException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                       
                 }  
            }).start();  
              
        }  
        //主线程  
        barrier.await();//阻塞当前线程直到latch中数值为零才执行  
        System.out.println("主线程执行！");  
  
    }  
  
}

写到这里大家不免有些疑问，countDownLatch和cyclicBarrier有什么区别呢，他们的区别：countDownLatch只能使用一次，而CyclicBarrier方法可以使用reset()方法重置，所以CyclicBarrier方法可以能处理更为复杂的业务场景。

我曾经在网上看到一个关于countDownLatch和cyclicBarrier的形象比喻，就是在百米赛跑的比赛中若使用 countDownLatch的话冲过终点线一个人就给评委发送一个人的成绩，10个人比赛发送10次，如果用CyclicBarrier，则只在最后一个人冲过终点线的时候发送所有人的数据，仅仅发送一次，这就是区别。