`
wu00yu11
  • 浏览: 59651 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

等待子线程结束

 
阅读更多
join future CountDownLanch CyclicBarrier
future 场景:
如果是一个多线程协作程序,比如菲波拉切数列,1,1,2,3,5,8...使用多线程来计算。
但后者需要前者的结果,就需要用callable接口了。
callable用法和runnable一样,只不过调用的是call方法,该方法有一个泛型返回值类型,你可以任意指定。

线程是属于异步计算模型,所以你不可能直接从别的线程中得到函数返回值。
这时候,Future就出场了。Futrue可以监视目标线程调用call的情况,当你调用Future的get()方法以获得结果时,当前线程就开始阻塞,直接call方法结束返回结果。

 public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        List<Future> fsL = new ArrayList<>();
        for (int i = 0; i < 200; i++) {
            int finalI = i;
            Future f = es.submit(new Callable() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("子线程在进行计算");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    int sum = 0;
                        sum += finalI;
                    return sum;
                }
            });
            fsL.add(f);
        }
        for (Future fu : fsL) {
            try {
                System.out.println("线程结果="+fu.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }


CountDownLanch 场景
转自:http://www.linzenews.com/develop/2002.html

一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。
CountDownLatch 是一个通用同步工具,它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器,或入口:在通过调用 countDown() 的线程打开入口前,所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待,或者使其在某项操作完成 N 次之前一直等待。
CountDownLatch 的一个有用特性是,它不要求调用 countDown 方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个 await。

举个例子:例如我们一群人(多个线程)要从北京一起到广州旅行,我们约定所有人都到达北京西站集合,当最后一个人到达北京西站的那一刻(计数器为0),我们才会一起同时进行下面的操作。
countdownLanch场景1:
示例用法: 下面给出了两个类,其中一组 worker 线程使用了两个倒计数锁存器:
第一个类是一个启动信号,在 driver 为继续执行 worker 做好准备之前,它会阻止所有的 worker 继续执行。
第二个类是一个完成信号,它允许 driver 在完成所有 worker 之前一直等待。
 class Driver { // ...
    void main() throws InterruptedException {
      CountDownLatch startSignal = new CountDownLatch(1);
      CountDownLatch doneSignal = new CountDownLatch(N);
 
      for (int i = 0; i < N; ++i) // create and start threads
        new Thread(new Worker(startSignal, doneSignal)).start();
 
      doSomethingElse();            // don't let run yet
      startSignal.countDown();      // let all threads proceed
      doSomethingElse();
      doneSignal.await();           // wait for all to finish
    }
  }
 
  class Worker implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
       this.startSignal = startSignal;
       this.doneSignal = doneSignal;
    }
    public void run() {
       try {
         startSignal.await();
         doWork();
         doneSignal.countDown();
 } catch (InterruptedException ex) {} // return;
    }
 
    void doWork() { ... }
  }

countdownLanch场景2:
另一种典型用法是,将一个问题分成 N 个部分,用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分,然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后,协调线程就能够通过 await。(当线程必须用这种方法反复倒计数时,可改为使用 CyclicBarrier。)
 class Driver2 { // ...
   void main() throws InterruptedException {
     CountDownLatch doneSignal = new CountDownLatch(N);
     Executor e = ...

     for (int i = 0; i < N; ++i) // create and start threads
       e.execute(new WorkerRunnable(doneSignal, i));

     doneSignal.await();           // wait for all to finish
   }
 }

 class WorkerRunnable implements Runnable {
   private final CountDownLatch doneSignal;
   private final int i;
   WorkerRunnable(CountDownLatch doneSignal, int i) {
      this.doneSignal = doneSignal;
      this.i = i;
   }
   public void run() {
      try {
        doWork(i);
        doneSignal.countDown();
      } catch (InterruptedException ex) {} // return;
   }

   void doWork() { ... }
 }

内存一致性效果:线程中调用 countDown() 之前的操作 happen-before 紧跟在从另一个线程中对应 await() 成功返回的操作。
CyclicBarrier 场景
转自:http://blog.csdn.net/shihuacai/article/details/8856407
一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。

需要所有的子任务都完成时,才执行主任务,这个时候就可以选择使用CyclicBarrier。


public class CyclicBarrierTest {

	public static void main(String[] args) throws IOException, InterruptedException {
		//如果将参数改为4,但是下面只加入了3个选手,这永远等待下去
		//Waits until all parties have invoked await on this barrier. 
		CyclicBarrier barrier = new CyclicBarrier(3);

		ExecutorService executor = Executors.newFixedThreadPool(3);
		executor.submit(new Thread(new Runner(barrier, "1号选手")));
		executor.submit(new Thread(new Runner(barrier, "2号选手")));
		executor.submit(new Thread(new Runner(barrier, "3号选手")));

		executor.shutdown();
	}
}

class Runner implements Runnable {
	// 一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)
	private CyclicBarrier barrier;

	private String name;

	public Runner(CyclicBarrier barrier, String name) {
		super();
		this.barrier = barrier;
		this.name = name;
	}

	@Override
	public void run() {
		try {
			Thread.sleep(1000 * (new Random()).nextInt(8));
			System.out.println(name + " 准备好了...");
			// barrier的await方法,在所有参与者都已经在此 barrier 上调用 await 方法之前,将一直等待。
			barrier.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
		System.out.println(name + " 起跑!");
	}
}
分享到:
评论

相关推荐

    主线程等待子线程结束代码

    我在工作的过程中遇到一个问题,需要主线程等等所有子线程执行完后再做某件事情,在网上找了很多代码,都没有真正解决这个问题. 现在我解决了这个问题,把代码共享出来供大家参考. 代码中有注释和注意事项,相信大家看过...

    C++ 等待线程结束

    当一个程序包含多个执行路径,即线程,有时我们需要确保某个线程执行完毕后再进行下一步操作,这就涉及到“等待线程结束”的功能。本篇文章将详细探讨如何在C++中实现这一功能。 首先,C++11引入了对线程支持的标准...

    Java简单实现“主线程等待所有子线程完成再继续”

    // 主线程在此处等待子线程完成 } catch (InterruptedException e) { e.printStackTrace(); } // 子线程完成后,主线程继续执行 ``` 然而,当有多个子线程时,逐一调用`join()`并不理想。这时,我们可以利用`...

    主线程等待子线程结束

    对于多线程而言,一个主要的难题就是如何线程是否都已经执行结束。 也就是说,需要在主线程开启子多线程后,直到子线程全部执行结束为止,回到主线程。

    JAVA主线程等待子线程执行完毕再执行[参照].pdf

    // 阻塞,等待子线程结束 future.get(); System.out.println("Now all thread done!"); // 关闭线程池 executorService.shutdown(); } private static void mainWork() { System.out.println("Main thread...

    python爬虫-08-主线程会等待子线程执行结束再结束.ev4.rar

    child.join() # 主线程等待子线程结束 ``` 2. 使用`Event`对象:`threading.Event`提供了一个信号机制,子线程完成任务后设置标志,主线程通过检查这个标志判断是否继续执行。 ```python import threading def ...

    如何等待一个已有线程自动结束的VC++代码

    当需要等待一个线程结束后再进行其他操作时,可以使用`WaitForSingleObject`函数。该函数接受一个线程句柄和一个超时值作为参数,会阻塞当前线程,直到指定的线程结束或者超时。 4. **示例代码**: ```cpp ...

    Python多线程:主线程等待所有子线程结束代码

    4. 对每个线程调用`join()`方法,使主线程等待子线程完成。 通过这种方式,你可以确保所有子任务在主线程结束前得以完成,这对于同步和资源清理等场景非常有用。同时,理解守护线程的概念和行为对于编写健壮的多...

    python 零基础学习篇多任务编程线程5 主线程会等待子线程执行结束再结束 .mp4

    python 零基础学习篇

    vc中获取一个线程的状态及返回值

    - 在VC++中,主线程可以通过`Joinable`线程类的`join()`成员函数等待子线程结束并获取返回值。 6. **VS2012中的线程支持**: - Visual Studio 2012引入了C++11标准库,其中包含`std::thread`类,提供了一种更现代...

    linux多线程程序实验,用不同线程完成一个矩阵乘法,以及子进程计算斐波那契数列,父进程输出结果

    6. 等待线程:父进程使用pthread_join()等待子线程结束,获取返回值。 六、代码实现 实验的代码可能包含以下几个部分: - 线程创建函数,用于初始化线程并启动计算。 - 矩阵乘法函数,接受矩阵参数并返回结果。 - ...

    实验二:线程的同步

    - 等待信号量:主线程通过调用`WaitForSingleObject()`函数等待子线程结束,即等待信号量变为可用状态。 - 释放信号量:子线程执行完毕后,会释放信号量,从而唤醒等待的主线程。 #### 四、源代码分析 给出的...

    PB多线程实现

    // 主线程等待子线程结束 } } ``` 总的来说,PB系列(尤其是PB12.5和PB.NET)提供了多种多线程实现方式,适应了不同开发需求。理解并掌握这些技术,能帮助开发者构建更加高效、响应迅速的PB应用程序。

    易语言判断多线程是否运行结束

    这个`判断线程结束`子程序内部可以封装上面提到的`线程.结束标志`或`线程.状态`的检查逻辑,提供简洁的调用接口。 综上所述,易语言提供了丰富的多线程编程功能,包括创建线程、控制线程以及判断线程状态等。通过...

    线程 (C语言)

    在主线程中可以通过`pthread_join`来等待子线程结束,并获取子线程的返回值。 ```c void pthread_exit(void *retval); ``` ```c int pthread_join(pthread_t thread, void **retval); ``` #### 控制线程 为了确保...

    如何程序运行时安全的终止线程

    `myThread.join()`确保主线程等待子线程结束后再继续,防止了“悬挂线程”。 另外,使用条件变量(`std::condition_variable`)也是一种有效的方法,特别是在线程需要等待某些条件满足时。主线程可以通过通知条件...

    实验八:Java多线程

    4. **主程序等待子线程结束**:通过循环检查子线程的`isAlive()`方法来等待子线程执行完毕。 #### 六、实验感想 通过本实验的学习,加深了对线程与进程概念的理解,并掌握了多线程在Java中的具体实现方法。特别是...

    C++多线程SOCKET收发

    // 等待子线程结束 return 0; } ``` 接下来,我们讨论SOCKET编程。在C++中,通常使用Winsock库(Windows)或BSD Sockets(跨平台)来实现SOCKET接口。SOCKET是操作系统提供的低级网络通信接口,它允许应用程序...

    多线程简易版

    在你的问题中,描述提到在等待子线程结束时遇到卡死现象,这很可能是由于线程等待不当或资源竞争导致的。 首先,我们需要理解多线程的基本概念。线程是程序的执行流,每个线程都有自己的程序计数器、栈和局部变量,...

Global site tag (gtag.js) - Google Analytics