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++11引入了对线程支持的标准...
// 主线程在此处等待子线程完成 } catch (InterruptedException e) { e.printStackTrace(); } // 子线程完成后,主线程继续执行 ``` 然而,当有多个子线程时,逐一调用`join()`并不理想。这时,我们可以利用`...
对于多线程而言,一个主要的难题就是如何线程是否都已经执行结束。 也就是说,需要在主线程开启子多线程后,直到子线程全部执行结束为止,回到主线程。
// 阻塞,等待子线程结束 future.get(); System.out.println("Now all thread done!"); // 关闭线程池 executorService.shutdown(); } private static void mainWork() { System.out.println("Main thread...
child.join() # 主线程等待子线程结束 ``` 2. 使用`Event`对象:`threading.Event`提供了一个信号机制,子线程完成任务后设置标志,主线程通过检查这个标志判断是否继续执行。 ```python import threading def ...
当需要等待一个线程结束后再进行其他操作时,可以使用`WaitForSingleObject`函数。该函数接受一个线程句柄和一个超时值作为参数,会阻塞当前线程,直到指定的线程结束或者超时。 4. **示例代码**: ```cpp ...
4. 对每个线程调用`join()`方法,使主线程等待子线程完成。 通过这种方式,你可以确保所有子任务在主线程结束前得以完成,这对于同步和资源清理等场景非常有用。同时,理解守护线程的概念和行为对于编写健壮的多...
python 零基础学习篇
- 在VC++中,主线程可以通过`Joinable`线程类的`join()`成员函数等待子线程结束并获取返回值。 6. **VS2012中的线程支持**: - Visual Studio 2012引入了C++11标准库,其中包含`std::thread`类,提供了一种更现代...
6. 等待线程:父进程使用pthread_join()等待子线程结束,获取返回值。 六、代码实现 实验的代码可能包含以下几个部分: - 线程创建函数,用于初始化线程并启动计算。 - 矩阵乘法函数,接受矩阵参数并返回结果。 - ...
- 等待信号量:主线程通过调用`WaitForSingleObject()`函数等待子线程结束,即等待信号量变为可用状态。 - 释放信号量:子线程执行完毕后,会释放信号量,从而唤醒等待的主线程。 #### 四、源代码分析 给出的...
// 主线程等待子线程结束 } } ``` 总的来说,PB系列(尤其是PB12.5和PB.NET)提供了多种多线程实现方式,适应了不同开发需求。理解并掌握这些技术,能帮助开发者构建更加高效、响应迅速的PB应用程序。
这个`判断线程结束`子程序内部可以封装上面提到的`线程.结束标志`或`线程.状态`的检查逻辑,提供简洁的调用接口。 综上所述,易语言提供了丰富的多线程编程功能,包括创建线程、控制线程以及判断线程状态等。通过...
在主线程中可以通过`pthread_join`来等待子线程结束,并获取子线程的返回值。 ```c void pthread_exit(void *retval); ``` ```c int pthread_join(pthread_t thread, void **retval); ``` #### 控制线程 为了确保...
`myThread.join()`确保主线程等待子线程结束后再继续,防止了“悬挂线程”。 另外,使用条件变量(`std::condition_variable`)也是一种有效的方法,特别是在线程需要等待某些条件满足时。主线程可以通过通知条件...
4. **主程序等待子线程结束**:通过循环检查子线程的`isAlive()`方法来等待子线程执行完毕。 #### 六、实验感想 通过本实验的学习,加深了对线程与进程概念的理解,并掌握了多线程在Java中的具体实现方法。特别是...
// 等待子线程结束 return 0; } ``` 接下来,我们讨论SOCKET编程。在C++中,通常使用Winsock库(Windows)或BSD Sockets(跨平台)来实现SOCKET接口。SOCKET是操作系统提供的低级网络通信接口,它允许应用程序...
在你的问题中,描述提到在等待子线程结束时遇到卡死现象,这很可能是由于线程等待不当或资源竞争导致的。 首先,我们需要理解多线程的基本概念。线程是程序的执行流,每个线程都有自己的程序计数器、栈和局部变量,...