import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.F

原创/朱季谦 在并发多线程场景下,存在需要获取各线程的异步执行结果,这时,就可以通过ExecutorService线程池结合Callable.Future来实现. 我们先来写一个简单的例子-- public class ExecutorTest { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executor = Executors

多线程的实现方式有实现Runnable接口和继承Thread类(实际上Thread类也实现了Runnable接口),但是Runnable接口的方式有两个弊端,第一个是不能获取返回结果,第二个是不能抛出exception.但是Callable接口很好的解决了上面的问题.下面介绍Callable接口的使用方法. 0.我们先看JDKAPI对callable接口的解释: public interface Callable<V> 返回结果并且可能抛出异常的任务.实现者定义了一个不带任何参数的叫做 cal

JAVA多线程实现方式主要有三种:继承Thread类.实现Runnable接口.使用ExecutorService.Callable.Future实现有返回结果的多线程.其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的. thread和runnable不讨论了. 太多地方可以找到他们的探究了 重点看callable和future, 先上一段代码: package com.future.chenjun.test; import java.util.concurrent.Callab

在课程<Principles Of Reactive Programming>里Week3的一节 "Promises, promises, promises"中,Erik Meijer举了一个例子,实现一个函数: def sequence[T](fs: List[Future[T]]): Future[List[T]] = {.....} 这个函数实际在Scala library的Future对象中有标准的实现. def  sequence[A, M[X] <: Tr

public class RunnableTestMain { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); /** * execute(Runnable x) 没有返回值.可以执行任务,但无法判断任务是否成功完成. */ pool.execute(new RunnableTest("Task1")); /** * submit(Runna

携带结果的任务 JDK5提供了有可返回值的任务的执行.java.util.concurrent中Callable与Futrue用以实现带返回值的任务执行. 使用Callable与Futrue与使用Runnable最大的两个区别在于: 1.Callable/Future是带返回值的:Runnable无法带返回值. 2.Callable/Future所执行的任务是可取消的.Runnable的任务无法取消. Callable接口 Callable 接口类似于 Runnable,两者都是为那些其实例可能

     attension:本文严禁转载. 一.前言 promise/future是一个非常重要的异步编程模型,它可以让我们摆脱传统的回调陷阱,从而使用更加优雅.清晰的方式进行异步编程.c++11中已经开始支持std::future/std::promise,那么为什么folly还要提供自己的一套实现呢?原因是c++标准提供的future过于简单,而folly的实现中最大的改进就是可以为future添加回调函数(比如then),这样可以方便的链式调用,从而写出更加优雅.间接的代码,然后,改进还

https://code.csdn.NET/DOC_Scala/chinese_scala_offical_document/file/Futures-and-Promises-cn.md#anchor_0 Philipp Haller, Aleksandar Prokopec, Heather Miller, Viktor Klang, Roland Kuhn, and Vojin Jovanovic著 简介 Future提供了一套高效便捷的非阻塞并行操作管理方案.其基本思想很简单,所谓Fut

多线程 等待一次性事件 future概念 背景:有时候,一个线程只等待另一个线程一次,而且需要它等待的线程的返回值. 案例:滴滴叫车时,点完了叫车按钮后,叫车的后台线程就启动了,去通知周围的出租车.这时,用户就可以去干别的了,而且用户只等待叫车的线程一次就够了,也就是有出租车应答了,这个等待就结束了,不会去再次等待有别的出租车应答.应答后,叫车的线程会返回出租车的车牌号,出租车的位置等信息,给叫车的用户. 问题:实现上面的场景,很容易就联想到用多线程去实现,但是std::thread是没有返回值

上一讲<C++11 并发指南四(<future> 详解一 std::promise 介绍)>主要介绍了 <future> 头文件中的 std::promise 类,本文主要介绍 std::packaged_task. std::packaged_task 包装一个可调用的对象,并且允许异步获取该可调用对象产生的结果,从包装可调用对象意义上来讲,std::packaged_task 与 std::function 类似,只不过 std::packaged_task 将其包

一,Future模式 假设有一个方法需要花费很长的时间才能获取运行结果.那么,与其一直等待结果,不如先拿一张 提货单.获取提货单并不耗费时间.这里提货单就称为Future角色获取Future角色的线程会在稍后使用Future角色来获取运行结果在处理开始时先返回Future角色,等到其他线程出来终止后,在将结果设置到Future角色中.二,示例程序 Data:访问数据的接口 RealData:实际处理数据的类 FutureData:表示RealData的提货单, Host:先拿提货单future实

为什么需要线程池?   每次都要new一个thread,开销大,性能差:不能统一管理:功能少(没有定时执行.中断等).   使用线程池的好处是,可重用,可管理.   Executor     4种线程池     // 可缓存线程池,如果缓存中没有可用的,则移出60秒未使用过的线程 ExecutorService service= Executors.newCachedThreadPool();   // 大小固定的线程池 ExecutorService service= Executors.ne

上一讲<C++11 并发指南四(<future> 详解二 std::packaged_task 介绍)>主要介绍了 <future> 头文件中的 std::packaged_task 类,本文主要介绍 std::future,std::shared_future 以及 std::future_error,另外还会介绍 <future> 头文件中的 std::async,std::future_category 函数以及相关枚举类型. std::future

简单地说,std::future 可以用来获取异步任务的结果,因此可以把它当成一种简单的线程间同步的手段.std::future 通常由某个 Provider 创建,你可以把 Provider 想象成一个异步任务的提供者,Provider 在某个线程中设置共享状态的值,与该共享状态相关联的 std::future 对象调用 get(通常在另外一个线程中) 获取该值,如果共享状态的标志不为 ready,则调用 std::future::get 会阻塞当前的调用者,直到 Provider 设置了共享

1.前言 第7节讲解JAVA的线程模型中就说到了Future,并解释了为什么可以主线程可以获得线程池任务的执行后结果,变成一种同步状态.秘密就在于Java将所有的runnable和callable任务,统一变成了callable,最终包装成了FutureTask对象,该类实现了Runnable接口和Future接口,所以FutureTask能够被线程执行.最终异步执行过程全部由该类控制逻辑,所以在get的时候锁住了该类,run方法执行的时候释放了锁,这样就满足了能够在异步线程执行完毕获取相关结果

std::future和std::promise std::future std::future期待一个返回,从一个异步调用的角度来说,future更像是执行函数的返回值,C++标准库使用std::future为一次性事件建模,如果一个事件需要等待特定的一次性事件,那么这线程可以获取一个future对象来代表这个事件. 异步调用往往不知道何时返回,但是如果异步调用的过程需要同步,或者说后一个异步调用需要使用前一个异步调用的结果.这个时候就要用到future. 线程可以周期性的在这个future上

import java.util.Random;import java.util.concurrent.*; /** * Created by chengtao on 17/12/4. * * 获取线程的结果 * <T> Future<T> submit(Callable<T> task); */public class Thread1001_CallableAndFuture { public static void main(String[] args)throws

以下内容整理自:https://www.cnblogs.com/my_life/articles/5401190.html future 是一个能从其他地方获取到一个值的对象,如果是在不同的线程中,则被synchronizing properly. std::condition_variable 可以用于异步事件的重复通知,但是有些时候可能只等待事件发生一次,比如:等待特定的航班,用条件变量大杀器有点浪费了.C++11 标准库提供了几种异步任务机制.通常 thread 不能返回线程执行的结果(可

回顾: 接上篇博客 java线程--三种创建线程的方式,这篇博客主要介绍第三种方式Callable和Future.比较继承Thread类和实现Runnable接口,接口更加灵活,使用更广泛.但这两种方式都没有返回值,要想返回相应的数据,就要使用Callable和Future方式. 基础: 1.Callable 还是从定义开始,Callable接口有返回值,并且可以抛出异常. /**(有返回值的任务,可能抛出异常) * A task that returns a result and may th

1 为什么需要Callable和Future Runnable没有返回值,也不抛异常,这样主线程不能知道子线程的执行结果. 为了解决这个问题就有了Callable和Future.Callable提供的call方法返回一个结果,然后把这个结果交给Future,主线程通过Future就能够获取子线程执行的结果了. Callable给子线程提供入参,Future提供子线程的返回值.FutureTask合二为一,它把Callable作为成员保存起来,而它本身就是一个Future. 2 什么是Future