future

When using an ExecutorService and Future objects (when submitting Runnable tasks), if I specify a timeout value to the future's get function, does the underlying thread get killed when a TimeoutException is thrown? It does not. Why would it? Unless you tell it to. There is a very valid concern here in case of a Callable for example. If you waited for the result for say 20 seconds and you did not get it, then you are not interested in the result anymore. At that time you should cancel the task at all. Something like this: Future<?> future = service.submit(new MyCallable()); try { future.get(100

I was experimenting with the new shiny concurrent.futures module introduced in Python 3.2, and I've noticed that, almost with identical code, using the Pool from concurrent.futures is way slower than using multiprocessing.Pool . This is the version using multiprocessing: def hard_work(n): # Real hard work here pass if __name__ == '__main__': 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

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? user2622016 std::async std::async is a neat and easy way to get a std::future , but: It does not always it start a new thread; pass std::launch::async as a first parameter to force it. auto f = std::async( std::launch::async, func ); The std::~future destructor can block until the new thread finishes auto sleep = [](int s) { std::this_thread::sleep_for(std::chrono::seconds(s)); }; { auto f = std::async( std::launch::async, sleep, 5 ); } Normally we expect

Hello here is a test code I wrote on MSVC12. Could someone tell me why the std::move when I pass parameters to the thread are not converting the variabes to RValue refs?? And what I should do. Thank you! ///some arbitrary long task std::string DumpFile(std::string path){ std::this_thread::sleep_for(std::chrono::seconds(10)); return path; } void run_promise(std::promise<std::string> &&_prom, std::string &&_path){ try { std::string val = DumpFile(std::move(_path)); _prom.set_value(val); } catch (...) { _prom.set_exception(std::current_exception()); } } std::future<std::string> ADumpFile(std:

I have this piece of code: impl ArcService for (Box<MiddleWare<Request>>, Box<ArcService>) { fn call(&self, req: Request, res: Response) -> Box<Future<Item = Response, Error = Error>> { box self.0.call(req).and_then(move |req| self.1.call(req, res)) } } pub trait ArcService: Send + Sync { fn call(&self, req: Request, res: Response) -> Box<Future<Item = Response, Error = Error>>; } pub trait MiddleWare<T>: Sync + Send { fn call<'a>(&'a self, param: T) -> Box<Future<Item = T, Error = Error> + 'a>; } type MiddleWareFuture<'a, I> = Box<Future<Item = I, Error = Error> + 'a>; impl MiddleWare<Request

I'm learning futures, and I'm trying to create a method that, take two futures as parameter ( f and g ) and return the first future that was successfully completed, otherwise it returns f or g . Some use cases to illustrate the behaviour of my method are : Future 1 | Future 2 | Result Success First Success Second Future 1 Success First Failure Second Future 1 Success Second Success First Future 2 Success Second Failure First Future 1 Failure First Failure Second Future 2 (because we had a failure on Future 1, so try to see what is the result Future 2) So I created this method : def successRace

What is wrong with the following code? When ran the program aborts with an unknown exception #include <iostream> #include <future> int main() { auto promise = std::promise<int>{}; auto future_one = promise.get_future(); promise.set_value(1); return 0; } The error output is terminate called after throwing an instance of 'std::system_error' what(): Unknown error -1 Aborted (core dumped) g++ --version for me gives g++ (Ubuntu 5.4.0-6ubuntu1~16.04.2) 5.4.0 20160609 Copyright (C) 2015 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty;