[Java Future][1] has `cancel` method, which can interrupt the thread, which runs the `Future` task. For example, if I wrap an _interruptible_ blocking call in a `Java Future` I can interrupt it later.

[Scala Future][2] provides no `cancel` method. Suppose I wrap an _interruptible_ blocking call in a `Scala Future`. How can I interrupt it? 


  [1]: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/Future.html
  [2]: http://www.scala-lang.org/api/current/index.html#scala.actors.Future

How to cancel Future in Scala?

What are the differences between Deferreds, Promises and Futures?  
Is there a generally approved theory behind all these three?

What are the differences between Deferred, Promise and Future in JavaScript?

After experiencing crashes when introducing nested calls of std::async in my real program, I was able to reproduce the problem in the following **minimum example**. It crashes often, but not always. Do you see anything what goes wrong, or is it a compiler or standard library bug? Note that the problem remains if `get()` calls to the futures are added.

    #include &lt;future&gt;
    #include &lt;vector&gt;
    
    int main (int, char *[])
    {
        std::vector&lt;std::future&lt;void&gt;&gt; v;
        v.reserve(100);
        for (int i = 0; i != 100; ++i)
        {
            v.emplace_back(std::async(std::launch::async, [] () {
                std::async(std::launch::async, [] { });
            }));
        }

        return 0;
    }


**I observe two different kinds of crashes:** (in about every fifth run)

 - Termination with *&quot;This application has requested the Runtime to terminate it in an unusual way.&quot;*
 - Termination after throwing an instance of *&#39;std::future_error&#39;, what():  Promise already satisfied*.


**Environment:**

 - Windows 7
 - gcc version 4.8.2 (i686-posix-dwarf-rev3, Built by
   MinGW-W64 project), as provided by Qt 5.3.2
 - Command line call: `g++ -std=c++11 -pthread futures.cpp`
 - Compiled and run on two independent machines

**Option `-pthread`?**
Could it be that in my environment for some reason the option `-pthread` is silently not taken into account? I observe the same behavior with and without that option.


Using C++11 futures: Nested calls of std::async crash: Compiler/Standard library bug?

I am a newbie to scala futures and I have a doubt regarding the return value of scala futures.

So, generally syntax for a scala future is 

    
     def downloadPage(url: URL) = Future[List[Int]] {
    
     }

I want to know how to access the `List[Int]` from some other method which calls this method.

In other words,

    val result = downloadPage(&quot;localhost&quot;) 

then what should be the approach to get `List[Int]` out of the future ?

I have tried using map method but not able to do this successfully.`

    



Accessing value returned by scala futures

When should I use `std::promise` over `std::async` or `std::packaged_task`?
Can you give me practical examples of when to use each one of them?

When to use promise over async or packaged_task?

I have a method that performs some task with a timeout. I use the ExecutorServer.submit() to get a Future object, and then I call future.get() with a timeout. This is working fine, but my question is the best way to handle checked exceptions that can be thrown by my task. The following code works, and preserves the checked exceptions, but it seems extremely clumsy and prone to break if the list of checked exceptions in the method signature changes.

Any suggestions on how to fix this? I need to target Java 5, but I&#39;d also be curious to know if there are good solutions in newer versions of Java.

	public static byte[] doSomethingWithTimeout( int timeout ) throws ProcessExecutionException, InterruptedException, IOException, TimeoutException {

		Callable&lt;byte[]&gt; callable = new Callable&lt;byte[]&gt;() {
			public byte[] call() throws IOException, InterruptedException, ProcessExecutionException {
				//Do some work that could throw one of these exceptions
				return null;
			}
		};

		try {
			ExecutorService service = Executors.newSingleThreadExecutor();
			try {
				Future&lt;byte[]&gt; future = service.submit( callable );
				return future.get( timeout, TimeUnit.MILLISECONDS );
			} finally {
				service.shutdown();
			}
		} catch( Throwable t ) { //Exception handling of nested exceptions is painfully clumsy in Java
			if( t instanceof ExecutionException ) {
				t = t.getCause();
			}
			if( t instanceof ProcessExecutionException ) {
				throw (ProcessExecutionException)t;
			} else if( t instanceof InterruptedException ) {
				throw (InterruptedException)t;
			} else if( t instanceof IOException ) {
				throw (IOException)t;
			} else if( t instanceof TimeoutException ) {
				throw (TimeoutException)t;
			} else if( t instanceof Error ) {
				throw (Error)t;
			} else if( t instanceof RuntimeException) {
				throw (RuntimeException)t;
			} else {
				throw new RuntimeException( t );
			}
		}
	}

=== UPDATE ===

Many people posted responses that recommended either 1) re-throwing as a general exception, or 2) re-throw as an unchecked exception. I don&#39;t want to do either of these, because these exception types (ProcessExecutionException, InterruptedException, IOException, TimeoutException) are important - they will each be handled differently by the calling processed. If I were not needing a timeout feature, then I would want my method to throw these 4 specific exception types (well, except for TimeoutException). I don&#39;t think that adding a timeout feature should change my method signature to throw a generic Exception type.

What is the best way to handle an ExecutionException?

I was experimenting with the new shiny [concurrent.futures][1] module introduced in Python 3.2, and I&#39;ve noticed that, almost with identical code, using the Pool from concurrent.futures is *way* slower than using [multiprocessing.Pool][2].

This is the version using multiprocessing:


    def hard_work(n):
        # Real hard work here
        pass

    if __name__ == &#39;__main__&#39;:
        from multiprocessing import Pool, cpu_count
    
        try:
            workers = cpu_count()
        except NotImplementedError:
            workers = 1
        pool = Pool(processes=workers)
        result = pool.map(hard_work, range(100, 1000000))


And this is using concurrent.futures:



    def hard_work(n):
        # Real hard work here
        pass

    if __name__ == &#39;__main__&#39;:
        from concurrent.futures import ProcessPoolExecutor, wait
        from multiprocessing import cpu_count
        try:
            workers = cpu_count()
        except NotImplementedError:
            workers = 1
        pool = ProcessPoolExecutor(max_workers=workers)
        result = pool.map(hard_work, range(100, 1000000))


Using a na&#239;ve factorization function taken from this [Eli Bendersky article][3], these are the results on my computer (i7, 64-bit, Arch Linux):

    [juanlu@nebulae]─[~/Development/Python/test]
    └[10:31:10] $ time python pool_multiprocessing.py 
    
    real	0m10.330s
    user	1m13.430s
    sys	0m0.260s
    [juanlu@nebulae]─[~/Development/Python/test]
    └[10:31:29] $ time python pool_futures.py 
    
    real	4m3.939s
    user	6m33.297s
    sys	0m54.853s


I cannot profile these with the Python profiler because I get pickle errors. Any ideas?

  [1]: http://docs.python.org/3.3/library/concurrent.futures.html
  [2]: http://docs.python.org/3.3/library/multiprocessing.html#multiprocessing.pool.Pool
  [3]: http://eli.thegreenplace.net/2013/01/16/python-paralellizing-cpu-bound-tasks-with-concurrent-futures/

ProcessPoolExecutor from concurrent.futures way slower than multiprocessing.Pool

To run some stuff in parallel or asynchronously I can use either an ExecutorService: ``&lt;T&gt; Future&lt;T&gt; submit(Runnable task, T result);`` or the CompletableFuture Api:``static &lt;U&gt; CompletableFuture&lt;U&gt; supplyAsync(Supplier&lt;U&gt; supplier, Executor executor);``
(Lets assume I use in both cases the same Executor)

Besides the return type `Future` vs. `CompletableFuture` are there any remarkable differences. Or When to use what?

And what are the differences if I use the `CompletableFuture` API with default `Executor` (the method without executor)?

ExecutorService.submit(Task) vs CompletableFuture.supplyAsync(Task, Executor)

In my flutter app, I have a future that handles http requests and returns the decoded data. But I want to be able to send an error if the `status code != 200` that can be gotten with the `.catchError()` handler.

**Heres the future:** 

    Future&lt;List&gt; getEvents(String customerID) async {
      var response = await http.get(
        Uri.encodeFull(...)
      );
    
      if (response.statusCode == 200){
        return jsonDecode(response.body);
      }else{
        // I want to return error here 
      }
    }


and when I call this function, I want to be able to get the error like:

    getEvents(customerID)
    .then(
      ...
    ).catchError(
      (error) =&gt; print(error)
    );

How do I return error from a Future in dart?

I have a method which returns a `List` of futures

    List&lt;Future&lt;O&gt;&gt; futures = getFutures();

Now I want to wait until either all futures are done processing successfully or any of the tasks whose output is returned by a future throws an exception. Even if one task throws an exception, there is no point in waiting for the other futures.

Simple approach would be to

    wait() {
    
       For(Future f : futures) {
         try {
           f.get();
         } catch(Exception e) {
           //TODO catch specific exception
           // this future threw exception , means somone could not do its task
           return;
         }
       }
    }

But the problem here is if, for example, the 4th future throws an exception, then I will wait unnecessarily for the first 3 futures to be available.

How to solve this? Will count down latch help in any way? I&#39;m unable to use Future `isDone` because the java doc says

    boolean isDone()
    Returns true if this task completed. Completion may be due to normal termination, an exception, or cancellation -- in all of these cases, this method will return true.


Waiting on a list of Future

I&#39;m confusing myself with difference between a future and a promise.

Obviously, they have different methods and stuff, but what is the actual use case?

Is it?:

 - when I&#39;m managing some async task, I use future to get the value &quot;in future&quot;
 - when I&#39;m the async task, I use promise as the return type to allow the user get a future from my promise

Futures vs. Promises

Java 8 introduces `CompletableFuture`, a new implementation of Future that is composable (includes a bunch of thenXxx methods). I&#39;d like to use this exclusively, but many of the libraries I want to use return only non-composable `Future` instances.

Is there a way to wrap up a returned `Future` instances inside of a `CompleteableFuture` so that I can compose it?

Transform Java Future into a CompletableFuture

I&#39;m looking for a way to convert an arbitrary length list of Futures to a Future of List. I&#39;m using Playframework, so ultimately, what I really want is a `Future[Result]`, but to make things simpler, let&#39;s just say `Future[List[Int]]` The normal way to do this would be to use `Future.sequence(...)` but there&#39;s a twist... The list I&#39;m given usually has around 10-20 futures in it, and it&#39;s not uncommon for one of those futures to fail (they are making external web service requests). Instead of having to retry all of them in the event that one of them fails, I&#39;d like to be able to get at the ones that succeeded and return those.   

For example, doing the following doesn&#39;t work

    import scala.concurrent._
    import scala.concurrent.ExecutionContext.Implicits.global
    import scala.util.Success
    import scala.util.Failure
    
    val listOfFutures = Future.successful(1) :: Future.failed(new Exception(&quot;Failure&quot;)) :: 
                        Future.successful(3) :: Nil
    
    val futureOfList = Future.sequence(listOfFutures)
    
    futureOfList onComplete {
      case Success(x) =&gt; println(&quot;Success!!! &quot; + x)
      case Failure(ex) =&gt; println(&quot;Failed !!! &quot; + ex)
    }

    scala&gt; Failed !!! java.lang.Exception: Failure

Instead of getting the only the exception, I&#39;d like to be able to pull the 1 and 3 out of there. I tried using `Future.fold`, but that apparently just calls `Future.sequence` behind the scenes. 

Thanks in advance for the help!




Scala: List[Future] to Future[List] disregarding failed futures

What is the best way to construct a completed future in Java? I have implemented my own `CompletedFuture` below, but was hoping something like this that already exists.


    public class CompletedFuture&lt;T&gt; implements Future&lt;T&gt; {
        private final T result;
    
        public CompletedFuture(final T result) {
            this.result = result;
        }
    
        @Override
        public boolean cancel(final boolean b) {
            return false;
        }
    
        @Override
        public boolean isCancelled() {
            return false;
        }
    
        @Override
        public boolean isDone() {
            return true;
        }
    
        @Override
        public T get() throws InterruptedException, ExecutionException {
            return this.result;
        }
    
        @Override
        public T get(final long l, final TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
            return get();
        }
    }

How to create a completed future in java

Is it possible to check if a `std::future` has finished or not? As far as I can tell the only way to do it would be to call `wait_for` with a zero duration and check if the status is `ready` or not, but is there a better way?

Get the status of a std::future

Both futures and promises block until they have calculated their values, so what is the difference between them?

How do Clojure futures and promises differ?

I want to do something after a lot of future function done,bu I do not know how to write the code in dart?
the code like this:

    for (var d in data) {
      d.loadData().then()
    }
    // when all loaded
    // do something here

but I don&#39;t want to wait them one by one:

    for (var d in data) {
      await d.loadData(); // NOT NEED THIS
    }

how to write those code in dart?

Dartlang wait more than one future

In Scala there is a Promise class that could be used to complete a Future manually. I am looking for an alternative in C#.

I am writing a test and I want it to look it similar to this: 

    // var MyResult has a field `Header`
    var promise = new Promise&lt;MyResult&gt;;
    
    handlerMyEventsWithHandler( msg =&gt;
        promise.Complete(msg);
    );

    // Wait for 2 seconds
    var myResult = promise.Future.Await(2000);

    Assert.Equals(&quot;my header&quot;, myResult.Header);

I understand that this is probably not the right pattern for C#, but I couldn&#39;t figure out a reasonable way to achieve the same thing even with somewhat different pattern.

EDIT: please note, that `async`/`await` doesn&#39;t help here, as I don&#39;t have a Task to await! I just have an access to a handler that will be run on another thread.


Promise equivalent in C#

Suppose I have several futures and need to wait until _either_ any of them fails _or_ all of them succeed. 

For example: Let there are 3 futures: `f1`, `f2`, `f3`. 

* If `f1` succeeds and `f2` fails I do not wait for `f3` (and return _failure_ to the client). 

* If `f2` fails while `f1` and `f3` are still running I do not wait for them (and return _failure_) 

* If `f1` succeeds and then `f2` succeeds I continue waiting for `f3`.

How would you implement it?

How to wait for several Futures?

is it possible to create your own futures in Dart to return from your methods, or must you always return a built in future return from one of the dart async libraries methods?

I want to define a function which always returns a `Future&lt;List&lt;Base&gt;&gt;` whether its actually doing an async call (file read/ajax/etc) or just getting a local variable, as below:

&lt;!-- language: lang-dart --&gt;

    List&lt;Base&gt; aListOfItems = ...;

    Future&lt;List&lt;Base&gt;&gt; GetItemList(){

        return new Future(aListOfItems);

    }

Dart, how to create a future to return in your own functions?

In asynchronous JavaScript, it is easy to run tasks in parallel and wait for all of them to complete using `Promise.all`:

    async function bar(i) {
      console.log(&#39;started&#39;, i);
      await delay(1000);
      console.log(&#39;finished&#39;, i);
    }

    async function foo() {
        await Promise.all([bar(1), bar(2)]);
    }

    // This works too:
    async function my_all(promises) {
        for (let p of promises) await p;
    }

    async function foo() {
        await my_all([bar(1), bar(2), bar(3)]);
    }

I tried to rewrite the latter in python:

    import asyncio

    async def bar(i):
      print(&#39;started&#39;, i)
      await asyncio.sleep(1)
      print(&#39;finished&#39;, i)

    async def aio_all(seq):
      for f in seq:
        await f
        
    async def main():
      await aio_all([bar(i) for i in range(10)])

    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()

But it executes my tasks sequentially.

What is the simplest way to await multiple awaitables?
Why doesn&#39;t my approach work?


Combine awaitables like Promise.all

The [`concurrent.futures.Executor.map`](http://docs.python.org/py3k/library/concurrent.futures.html#concurrent.futures.Executor.map) takes a variable number of iterables from which the function given is called. **How should I call it if I have a generator that produces tuples that are normally unpacked in place?**

The following doesn&#39;t work because each of the generated tuples is given as a different argument to map:

    args = ((a, b) for (a, b) in c)
    for result in executor.map(f, *args):
        pass

Without the generator, the desired arguments to map might look like this:

    executor.map(
        f,
        (i[0] for i in args),
        (i[1] for i in args),
        ...,
        (i[N] for i in args),
    )



Pass multiple parameters to concurrent.futures.Executor.map?

I&#39;m trying to explore all the options of the new C++11 standard in depth, while using std::async and reading its definition, I noticed 2 things, at least under linux with gcc 4.8.1 :

 - it&#39;s called *async*, but it got a really &quot;sequential behaviour&quot;, basically in the row where you call the *future* associated with your async function *foo*, the program blocks until the execution of *foo* it&#39;s completed. 
 - it depends on the exact same external library as others, and better, non-blocking solutions, which means `pthread`, if you want to use `std::async` you need pthread.

at this point it&#39;s natural for me asking why choosing std::async over even a simple set of functors ? It&#39;s a solution that doesn&#39;t even scale at all, the more future you call, the less responsive your program will be.

Am I missing something ? Can you show an example that is granted to be executed in an async, non blocking, way ?

Why should I use std::async?

How large is Scala&#39;s thread pool for futures?

My Scala application makes many millions of `future {}`s and I wonder if there is anything I can do to optimize them by configuring a thread pool.

Thank you.

How to configure a fine tuned thread pool for futures?

Is it possible to disable future date from today?

Let say today is 23/10/2010, so 24/10/2010 onwards are disabled.

Sorry I am very new in jQuery and JavaScript.

Disable future dates in jQuery UI Datepicker

I was wondering when I should use the future builder. For example, if I want to make an http request and show the results in a list view, as soon as you open the view, should I have to use the future builder or just build a `ListViewBuilder` like:

    new ListView.builder(
            itemCount: _features.length,
            itemBuilder: (BuildContext context, int position) {
    ...stuff here...
    }


Moreover, if I don&#39;t want to build a list view but some more complex stuff like circular charts, should I have to use the future builder?

Hope it&#39;s clear enough!

When should I use a FutureBuilder?

I am reading through the Scala Cookbook (http://shop.oreilly.com/product/0636920026914.do)

There is an example related to Future use that involves for comprehension.

So far my understanding about for comprehension is when use with a collection it will produce another collection with the same type. For example, if each  `futureX` is of type `Future[Int]`, the following should also be of type `Future[Int]`:

    for {
       r1 &lt;- future1
       r2 &lt;- future2
       r3 &lt;- future3
    } yield (r1+r2+r3)


Could someone explain me what exactly happening when use `&lt;-` in this code?
I know if it was a generator it will fetch each element by looping.



Scala&#39;s &quot;for comprehension&quot; with futures

I&#39;ve given `concurrent.futures.ThreadPoolExecutor` a bunch of tasks, and I want to wait until they&#39;re all completed before proceeding with the flow. How can I do that, without having to save all the futures and call `wait` on them? (I want an action on the executor.)

Python: Wait on all of `concurrent.futures.ThreadPoolExecutor`&#39;s futures

Let&#39;s say I&#39;m getting a (potentially big) list of images to download from some URLs. I&#39;m using Scala, so what I would do is :

    import scala.actors.Futures._
    
    // Retrieve URLs from somewhere
    val urls: List[String] = ...
    
    // Download image (blocking operation)
    val fimages: List[Future[...]] = urls.map (url =&gt; future { download url })
    
    // Do something (display) when complete
    fimages.foreach (_.foreach (display _))

I&#39;m a bit new to Scala, so this still looks a little like magic to me :

  * Is this the right way to do it? Any alternatives if it is not?
  * If I have 100 images to download, will this create 100 threads at once, or will it use a thread pool?
  * Will the last instruction (`display _`) be executed on the main thread, and if not, how can I make sure it is?

Thanks for your advice!

Asynchronous IO in Scala with futures

When using an `ExecutorService` and `Future` objects (when submitting `Runnable` tasks), if I specify a timeout value to the future&#39;s get function, does the underlying thread get killed when a `TimeoutException` is thrown? 

Does a Future timeout kill the Thread execution

I want to write an asynchronous method that returns a [`CompletableFuture`][1]. The only purpose of the future is to track when the method is complete, not its result. Would it be better to return `CompletableFuture&lt;Void&gt;` or `CompletableFuture&lt;?&gt;`? Is there a reason to prefer one or the other, or are they interchangeable?

* [`CompletableFuture`][1] itself returns `CompletableFuture&lt;Void&gt;` from many of its methods.
* `java.nio` has a `Future&lt;Void&gt;` in [`AsynchronousSocketChannel`][4]: `Future&lt;Void&gt; connect(SocketAddress remote)`.
* On the other hand, `java.util.concurrent` classes like [`ExecutorService`][2] and [`ScheduledExecutorService`][3] return `Future&lt;?&gt;`: for instance, with `Future&lt;?&gt; submit(Runnable task)`.

Note that I&#39;m only asking about return types, not parameter lists, variable declarations, or other contexts.

[1]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html
[2]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
[3]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html
[4]: http://docs.oracle.com/javase/8/docs/api/java/nio/channels/AsynchronousSocketChannel.html

Return CompletableFuture&lt;Void&gt; or CompletableFuture&lt;?&gt;?

What&#39;s the difference between `Future` and `Promise`?  
They both act like a placeholder for future results, but where is the main difference?

What&#39;s the difference between a Future and a Promise?

We are developing some systems in our company in Scala and we have some doubts. We were discussing about how to map the future exceptions and we don&#39;t know when we should use the option 1 or the option 2.

    val created: Future[...] = ???

Option 1:
    &lt;!-- language: scala --&gt;

    val a = created recover {   
      case e: database.ADBException =&gt;
        logger.error(&quot;Failed ...&quot;, e)
        throw new business.ABusinessException(&quot;Failed ...&quot;, e) 
    }

Option 2:
    
    val a = created recoverWith {   
      case e: database.ADBException =&gt;
        logger.error(&quot;Failed ...&quot;, e)
        Future.failed(new business.ABusinessException(&quot;Failed ...&quot;, e))
    }

Could someone explain when should i do the option 1 or the option 2? What is the diff?

All Future Solutions on Gang of Coders

Total of 33 Future Solutions