Java实现主线程等待子线程

本文介绍两种主线程等待子线程的实现方式,以5个子线程来说明:

1、使用Thread的join()方法,join()方法会阻塞主线程继续向下执行。

2、使用Java.util.concurrent中的CountDownLatch,是一个倒数计数器。初始化时先设置一个倒数计数初始值,每调用一次countDown()方法,倒数值减一,他的await()方法会阻塞当前进程,直到倒数至0。

join方式代码如下:

[java] view plain copy

  1. package com.test.thread;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class MyThread extends Thread
  5. {
  6. public MyThread(String name)
  7. {
  8. this.setName(name);
  9. }
  10. @Override
  11. public void run()
  12. {
  13. System.out.println(this.getName() + " staring...");
  14. System.out.println(this.getName() + " end...");
  15. }
  16. /**
  17. * @param args
  18. */
  19. public static void main(String[] args)
  20. {
  21. System.out.println("main thread starting...");
  22. List<MyThread> list = new ArrayList<MyThread>();
  23. for (int i = 1; i <= 5; i++)
  24. {
  25. MyThread my = new MyThread("Thrad " + i);
  26. my.start();
  27. list.add(my);
  28. }
  29. try
  30. {
  31. for (MyThread my : list)
  32. {
  33. my.join();
  34. }
  35. }
  36. catch (InterruptedException e)
  37. {
  38. e.printStackTrace();
  39. }
  40. System.out.println("main thread end...");
  41. }
  42. }

运行结果如下:

main thread starting...
Thrad 2 staring...
Thrad 2 end...
Thrad 4 staring...
Thrad 4 end...
Thrad 1 staring...
Thrad 1 end...
Thrad 3 staring...
Thrad 3 end...
Thrad 5 staring...
Thrad 5 end...
main thread end...
CountDownLatch方式代码如下:

[java] view plain copy

  1. package com.test.thread;
  2. import java.util.concurrent.CountDownLatch;
  3. public class MyThread2 extends Thread
  4. {
  5. private CountDownLatch count;
  6. public MyThread2(CountDownLatch count, String name)
  7. {
  8. this.count = count;
  9. this.setName(name);
  10. }
  11. @Override
  12. public void run()
  13. {
  14. System.out.println(this.getName() + " staring...");
  15. System.out.println(this.getName() + " end...");
  16. this.count.countDown();
  17. }
  18. /**
  19. * @param args
  20. */
  21. public static void main(String[] args)
  22. {
  23. System.out.println("main thread starting...");
  24. CountDownLatch count = new CountDownLatch(5);
  25. for (int i = 1; i <= 5; i++)
  26. {
  27. MyThread2 my = new MyThread2(count, "Thread " + i);
  28. my.start();
  29. }
  30. try
  31. {
  32. count.await();
  33. }
  34. catch (InterruptedException e)
  35. {
  36. e.printStackTrace();
  37. }
  38. System.out.println("main thread end...");
  39. }
  40. }

运行结果如下:

main thread starting...
Thread 2 staring...
Thread 2 end...
Thread 4 staring...
Thread 4 end...
Thread 1 staring...
Thread 1 end...
Thread 3 staring...
Thread 3 end...
Thread 5 staring...
Thread 5 end...
main thread end...

时间: 2024-10-03 13:27:44

Java实现主线程等待子线程的相关文章

JAVA进阶----主线程等待子线程各种方案比较(转)

创建线程以及管理线程池基本理解 参考原文链接:http://www.oschina.net/question/12_11255?sort=time 一.创建一个简单的java线程 在 Java 语言中,一个最简单的线程如下代码所示: Java代码   Runnable runnable = new Runnable(){ public void run(){ System.out.println("Run"); } } 可通过下面一行代码来启动这个线程: new Thread(runn

设置主线程等待子线程执行的方法

首先要注意的是: 1.java的Main线程结束之后,子线程还在运行.其实主线程已经退出了,但是JVM守护线程会等待所有的线程结束,才会退出.所以我们可以看到,子线程依然在继续执行. 2.那么如何实现主线程等待子线程的执行之后再结束,这个就要用到CountDownLatch,设置要执行的线程的个数,然后再子线程的run方法中调用countDown()的方法,递减线程的计数.在主线程结束之前,调用await()的方法,一直等待. 实现如下: public class Main extends Th

C#主线程等待子线程运行结束

佐左佑右 原文 C#主线程等待子线程运行结束 由于主程序中调用matlab的dll文件进行计算要用较长的时间,主界面会有很长时间的卡顿,造成的用户感受十分不好,因此我想在调用时,将调用放入子线程中,然后在主线程中弹出一个提示框,显示数据正在加载,等子线程运行结束后,主线程继续工作. 使用的是http://hi.baidu.com/oktell/item/5527f51d93abb4a5feded5a8中所提到的方法,用了这篇文章中的第一个方式,即不带参数的. 之后在其中加入了显示和关闭提示框的代

Java并发编程原理与实战六:主线程等待子线程解决方案

本文将研究的是主线程等待所有子线程执行完成之后再继续往下执行的解决方案 public class TestThread extends Thread { public void run() { System.out.println(this.getName() + "子线程开始"); try { // 子线程休眠五秒 Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.

Java多线程--让主线程等待子线程执行完毕

使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行,那么接下来介绍一种简单的方式使主线程等待. java.util.concurrent.CountDownLatch 使用countDownLatch.await()方法非常简单的完成主线程的等待: public class ThreadWait { public static void main(String[] args) throws InterruptedException { int threadNumber

Java线程池主线程等待子线程执行完成

今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~ 工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了. 一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程,  往往需要让主线程指定后, 等待子线程的完成. 这里有几种方式. 站在 主线程的角度, 我们可以分为主动式和被动式. 主动式指主线主动去检测某个标志位, 判断子线程是否已经完成. 被动式指主线程被动的等待子线程的结束, 很明

Java 并发编程中的 CountDownLatch 锁用于多个线程同时开始运行或主线程等待子线程结束

Java 5 开始引入的 Concurrent 并发软件包里面的 CountDownLatch 其实可以把它看作一个计数器,只不过这个计数器的操作是原子操作,同时只能有一个线程去操作这个计数器,也就是同时只能有一个线程去减这个计数器里面的值.CountDownLatch的一个非常典型的应用场景是:有一个任务想要往下执行,但必须要等到其他的任务执行完毕后才可以继续往下执行.假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法,其他的任务执行完自己的任务后调

Java多线程协作CountDownLatch,主线程等待子线程结束

CountDownLatch,一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待. 主要方法 public CountDownLatch(int count);构造方法参数指定了计数的次数 public void countDown(); countDown方法,当前线程调用此方法,则计数减一 public void await() awaint方法,调用此方法会一直阻塞当前线程,直到计时器的值为0 ===============================

Android主线程、子线程通信(Thread+handler)

Android是基于Java的,所以也分主线程,子线程! 主线程:实现业务逻辑.UI绘制更新.各子线程串连,类似于将军: 子线程:完成耗时(联网取数据.SD卡数据加载.后台长时间运行)操作,类似于小兵: 一.子线程向主线程发消息(Thread+handler): 1.主线程中定义Handler: Java代码   Handler mHandler = new Handler(){ @Override public void handleMessage(Message msg) { super.h