3

我有以下Foo使用类的FooProcessor类。所以我想做的是，在运行 cp1 实例进程方法时，我想并行运行cp2.process().

public class Foo {

    public static void main(String [] args){

        FooProcessor cp1 = new FooProcessor();
        FooProcessor cp2 = new FooProcessor();

        cp1.process();
        // in parallel process cp2.process();
    }

}

public class FooProcessor {
    public void process(){
        System.out.println("Processing..");
    }
}

但是，我希望 cp1 按顺序运行，所以我希望它运行并完成，如果 cp2 没有完成或失败，那很好。如果它没有失败，我想加入结果。它没有返回此示例中的任何内容，但我想返回结果。

为此，应该使用TaskExecutor吗？还是线程？

我只希望 cp2 与 cp1 并行运行。或者如果我添加更多让我们说 cp3，我希望它也与 cp1 并行运行。

4

5 回答 5

5

总之，我将实现它的方式：

  • 例如，通过ExecutorService运行您的不同进程ExecutorService executor = Executors.newFixedThreadPool(nThreads);
  • 将所有任务的Futures存储在列表中（由 ExecutorService#submit 返回）
  • 等待future1.get()完成，future1cp1链接的future在哪里
  • 一旦get返回（cp1 已完成）取消所有其他期货，（shutdownNow如果您不再需要执行程序，则取消执行程序服务）
  • 为了使取消过程正常工作，您的 cp2、cp3 等需要实施中断政策，使他们尽快停止正在做的事情。
于 2012-06-27T15:41:53.857 回答
0

您当然可以使用简单明了的线程
如果您知道需要向处理器类添加更多方法，并且对于它的给定实例以保持执行顺序 - 假设您首先运行方法 foo，然后运行方法 bar，然后您希望它们异步运行，但保持执行顺序（首先是 foo，然后是 bar），我会考虑使用Active Object模式。
我也推荐使用这种方法，因为对于处理器类的用户来说，它会隐藏实现细节。
另外，考虑提供一个装饰器/wrapper 将为您的对象提供这种异步能力 - 这样您将能够控制哪些对象异步运行，哪些不是，并且您不必使用异步调用所需的代码“污染”您的处理器类。
在这种情况下的使用示例将是 -

AsyncProcessor ap  = new AsyncProcessor(p1);
ap.process();  //executed asynchronously
Proccessor p2 = new Processor();
p2.process(); //executed synchronously



另一种方法是使用您提到的执行器 - 这可以通过实现线程池并将“执行单元推送给它”来实现。
一个执行单元将包含目标对象（cp1，cp2，...）和执行方法（当前 - 仅进程）
线程将从队列中获取“一个执行单元”并运行它们。
实现类似于活动对象，但用户的“接口”不同，因为它使用“TaskExecutor”类为其提供“执行单元”

于 2012-06-27T03:32:18.280 回答
0

线程将是一个不错的选择...类似于接受新线程并启动它们的方法...

于 2012-06-27T03:35:25.907 回答
0

根据https://stackoverflow.com/a/2269177/454167，

你可以使用类似AsyncTaskExecutor[1] 的东西，它返回一个Future对象。然后，您可以等待 Future 知道 cp2 是否返回成功。

[1] http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/core/task/AsyncTaskExecutor.html#submit%28java.lang.Runnable%29

于 2012-06-27T03:35:49.137 回答
0

如果您正在编写自己的独立应用程序，那么使用线程可能是最简单的方法。如果您在 Java EE 环境中，则不应创建自己的 Thread 对象，而应使用其他一些机制（例如发送消息并让消息侦听器处理您发送的信号）。这是为了让 Java EE 容器控制资源利用，例如线程池。

使用线程的示例：

Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
         executeSomeCodeInP1();
    }
});

Thread t2 = new Thread(new Runnable() {
    @Override
    public void run() {
         executeSomeCodeInP2();
    }
});

t1.start();
t2.start();

// if you want to wait for both threads to finish before moving on, 
// "join" the current thread
t1.join();
t2.join();
于 2012-06-27T04:46:50.880 回答