Groovy 从gpars并行执行器异步收集结果

我们有一些使用ThreadPoolExecutor和CompletionService的Java代码。任务以大批量提交到池中；结果将转到完成服务，在该服务中，我们可以在可用时收集已完成的任务，而无需等待整个批次完成：

 ThreadPoolExecutor _executorService =
            new ThreadPoolExecutor(MAX_NUMBER_OF_WORKERS, new LinkedBlockingQueue(20));
 CompletionService _completionService =
            new ExecutorCompletionService<Callable>(_executorService)

//submit tasks
_completionService.submit( some task);

//get results
while(...){
   Future result = _completionService.poll(timeout);
   if(result)
      //process result
}

ThreadPoolExecutor\u executor服务=
新的ThreadPoolExecutor（最大工作线程数，新的LinkedBlockingQueue（20））；
CompletionService\u CompletionService=
新的ExecutorCompletionService（\u executorService）
//提交任务
_completionService.submit（某些任务）；
//取得成果
而（…）{
未来结果=_completionService.poll（超时）；
如果（结果）
//过程结果
}

池中的工人总数为工人的最大数量；在没有可用辅助工的情况下提交的任务将排队；最多可以将20个任务排入队列，然后拒绝任务

这种方法的对应物是什么？

---

在阅读关于gpars并行性的文章时，我发现了许多潜在的选项：

collectManyParallel（）

，

anyParallel（）

，

fork/join

，等等，我甚至不确定要测试哪些选项。我希望在文档中找到一些关于“完成”或“完成服务”的比较，但什么也没找到。我正在寻找一些方向/指针，从那些有GPAR经验的人那里开始。

动态收集结果，限制生产者-这需要一个数据流解决方案。请在下面找到可运行的演示示例：

import groovyx.gpars.dataflow.DataflowQueue
import groovyx.gpars.group.DefaultPGroup
import groovyx.gpars.scheduler.DefaultPool

import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit

int MAX_NUMBER_OF_WORKERS = 10

ThreadPoolExecutor _executorService =
        new ThreadPoolExecutor(MAX_NUMBER_OF_WORKERS, MAX_NUMBER_OF_WORKERS, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(200));

final group = new DefaultPGroup(new DefaultPool(_executorService))
final results = new DataflowQueue()

//submit tasks
30.times {value ->
    group.task(new Runnable() {
        @Override
        void run() {
            println 'Starting ' + Thread.currentThread()
            sleep 5000
            println 'Finished ' + Thread.currentThread()
            results.bind(value)
        }
    });
}
group.task {
    results << -1  //stop the consumer eventually
}

//get results
while (true) {
    def result = results.val
    println result
    if (result == -1) break
    //process result
}

group.shutdown()

导入groovyx.gpars.dataflow.DataflowQueue
导入groovyx.gpars.group.DefaultPGroup
导入groovyx.gpars.scheduler.DefaultPool
导入java.util.concurrent.LinkedBlockingQueue
导入java.util.concurrent.ThreadPoolExecutor
导入java.util.concurrent.TimeUnit
int最大工人数量=10
ThreadPoolExecutor\u Executor服务=
新的ThreadPoolExecutor（最大工作线程数，最大工作线程数，1000，TimeUnit.ms，新的LinkedBlockingQueue（200））；
最终组=新的DefaultPGroup（新的DefaultPool（_executorService））
最终结果=新数据流队列（）
//提交任务
30.5倍{值->
group.task（新的Runnable（）{
@凌驾
无效运行（）{
println'Starting'+Thread.currentThread（）
睡5000
println'Finished'+Thread.currentThread（）
结果绑定（值）
}
});
}
组任务{
结果看起来很有趣，我会测试一下，泰