future

According to http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html isDone returns true if cancel(boolean mayInterruptIfRunning) was called. After this method returns, subsequent calls to isDone() will always return true. However, it is possible that task is running and mayInterruptIfRunning is set to false . So, what should return isDone() right after that call? true because of cancel (which is wrong)? Also, it's not clear whether cancel(boolean) method returns false . P. S. I'm implementing some simple thread pool, so I'm inheriting from Future . After cancel(...) , isDone

I have a for loop which I am trying to parallelize using CompletableFuture. for (int i = 0; i < 10000; i++) { doSomething(); doSomethingElse(); } What I have till now is: for (int i = 0; i < 10000; i++) { CompletableFuture.runAsync(() -> doSomething()); CompletableFuture.runAsync(() -> doSomethingElse()); } I guess this serves the purpose but there is a requirement to print log just before the start and end of all the processing. If I do this: log("Started doing things"); for (int i = 0; i < 10000; i++) { CompletableFuture.runAsync(() -> doSomething()); CompletableFuture.runAsync(() ->

I'm curious about the best way to recursively build a chain of Akka futures which will run sequentially, if a doWork call in a future fails, the future should be retried up to 3 times, the chain should fail if it runs out of retry attempts. Assuming all doWork calls pass the returned future futChain should only complete. object Main extends App { val futChain = recurse(2) def recurse(param: Int, retries: Int = 3): Future[String] { Future { doWorkThatMayFailReturningString(param...) } recoverWith { case e => if (retries > 0) recurse(param, retries -1) else Future.failed(e) } flatMap { strRes =>

I've just started experimenting with futures/tokio in Rust. I can do really basic things with just futures or just with streams. I was wondering how you can select between future and a stream. How can I extend the toy problem from the tokio documentation to use tokio_timer::Timer to do a timed HTTPS request? extern crate futures; extern crate native_tls; extern crate tokio_core; extern crate tokio_io; extern crate tokio_tls; use std::io; use std::net::ToSocketAddrs; use futures::Future; use native_tls::TlsConnector; use tokio_core::net::TcpStream; use tokio_core::reactor::Core; use tokio_tls:

I have certain flow that runs async using the CompletableFuture , e.g.: foo(...) .thenAccept(aaa -> { if (aaa == null) { break! } else { ... } }) .thenApply(aaa -> { ... }) .thenApply(... So if my foo() returns null (in a future) I need to break very soon, otherwise, the flow continue. For now I have to check for null all the way, in every future block; but that is ugly. Would this be possible with CompletableFuture ? EDIT With CompletableFuture you can define your flow of async tasks, that are executed one after the other. For example, you may say: Do A, and when A finishes, do B, and then do