Question

我真的想做这样的事情：

 Callable<MyObject> myCallable = ....
 Future<MyObject> = new Thread( myCallable).start();

我基本上想要启动一个与我的主任务并行运行的长时间运行的任务，并且我不希望池或线程重用。 Executors的东西似乎非常集中，它需要我关闭池，所有这些都是我不想做的。

我希望使用“Callable / Future”模式，因为我后来可能会引入Executors，但是目前的情况是它们只是开销。

有什么建议吗？

Answer 1

尝试FutureTask。它没有对Executor框架的任何显式依赖，可以按原样实例化，也可以扩展它以自定义它。

Answer 2

好吧，你可以很容易地编写一个辅助方法：

public static Future<T> createFuture(Callable<T> callable)
{
    ExecutorService service = Executors.newSingleThreadExecutor();
    Future<T> ret = service.submit(callable);
    // Let the thread die when the callable has finished
    service.shutdown();
    return ret;
}

编辑：要展开alphazero's answer，您可以像这样使用FutureTask：

FutureTask<MyObject> future = new FutureTask<MyObject>(myCallable);
new Thread(future).start(); // FutureTask implements Runnable
// Now use the future however you want

是的，我会说这比我的第一个答案更好：）

Answer 3

可调用/未来的东西基于线程池。如果您需要多次执行相同的操作，我强烈建议您使用池。

如果您不想使用线程池，那么我建议您手动使用线程。通过使用单个线程并加入它并不难做到你想要的。

class X extends Thread {
   MyObject result;

   public void run() {
      // .. do the operation here. Set result
   }

   public MyObject getResult() {
      // This will block until the thread is complete
      join();
      return result;
   }
}

要运行此电话：

X x = new X();
x.start();

最终你将调用getResult，它将阻塞直到X的线程完成：

x.getResult();

如何在不使用ExecutorService的情况下获得Future <myobject>？</myobject>

3 个答案: