future

I am using the Future API from Scala 2.10.X. Here is my use case: object Class1 { def apply(f: (Int) => Future[String])(i: Int): Future[String] = { val start = DateTime.now val result = f(i) result.onComplete{ case _ => println("Started at " + start + ", ended at " + DateTime.now) } result } } Pretty simple I think: I'm adding an onComplete callback to my future. Now, I'm wondering if there is a way to add a callback for when the onComplete is done executing - in this example know when the logging is done. Let's say my result instance has 3 onComplete registered, can I know when all of them

Hi, I'm using Scala 2.10 with the new futures library and I'm trying to write some code to test an infinite loop. I use a scala.concurrent.Future to run the code with the loop in a separate thread. I would then like to wait a little while to do some testing and then kill off the separate thread/future. I have looked at Await.result but that doesn't actually kill the future. Is there any way to timeout or kill the new Scala 2.10 futures? I would prefer not having to add external dependencies such as Akka just for this simple part. Do not try it at home. import scala.concurrent._ import scala

This is a follow-on from a previous question ( here ), but I'm working on a multithreaded application and I would like to post a Boost packaged_task to a threaded io_service. I'm stuck using a C++03 compiler (so std::move is out), and the packaged_task is not copyable. I've tried wrapping it in a shared_ptr and passing that, and a lot of other things. Here is my current attempt and the subsequent compiler errors. Any idea how to get this to work? boost::asio::io_service io_service; boost::thread_group threads; boost::asio::io_service::work work(io_service); for (int i = 0; i < maxNumThreads; +

Is there any particular advantage in decoupling the get method from the Future class (where I'd expect it to reside) and to instead force the coder to have to know about this external two-method class called Await ? Is there any particular advantage in decoupling the get method from the Future class Yes, to make it difficult for the developer to do the wrong thing . A Future represents a computation which will complete in the future and might not be available at the current invocation point. If you need to block a future, why not execute it synchronously? Whats the point of scheduling it on

I think I have a memory leak in my Android live wallpaper. Whenever I rotate the screen, the amount of memory garbage collected increases by 50kb and doesn't go back down. I think it may be caused by a scheduled future, so I'm going to present a scenario to see if that's the case. Let's say you have a class (let's call it Foo) that has the following members. private ScheduledFuture<?> future; private final ScheduledExecutorService scheduler = Executors .newSingleThreadScheduledExecutor(); private final Runnable runnable = new Runnable() { public void run() { // Do stuff } }; And now you set a

In Scala, I can use Await to wait for a future to complete. However, if I have registered a callback to run upon completion of that future, how can I wait not only for the future to complete but also for that callback to finish? Here is a minimal but complete program to illustrate the problem: import scala.concurrent.ExecutionContext.Implicits.global import scala.concurrent.duration.Duration import scala.concurrent.{ Await, Future } object Main { def main(args: Array[String]): Unit = { val f: Future[Int] = Future(0) f.onSuccess { case _ => Thread.sleep(10000) println("The program waited