Я только что нашел CompletionService в этом сообщении в блоге. Однако это действительно демонстрирует преимущества CompletionService над стандартным ExecutorService. Один и тот же код может быть написан с помощью. Итак, когда полезно использовать CompletionService?
Можете ли вы дать короткий образец кода, чтобы сделать его кристально чистым? Например, этот пример кода просто показывает, где не требуется CompletionService (= эквивалентно ExecutorService)
ExecutorService taskExecutor = Executors.newCachedThreadPool();
// CompletionService<Long> taskCompletionService =
// new ExecutorCompletionService<Long>(taskExecutor);
Callable<Long> callable = new Callable<Long>() {
@Override
public Long call() throws Exception {
return 1L;
}
};
Future<Long> future = // taskCompletionService.submit(callable);
taskExecutor.submit(callable);
while (!future.isDone()) {
// Do some work...
System.out.println("Working on something...");
}
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
Ответ 1
С ExecutorService, после того как вы отправили задачи для запуска, вам нужно вручную написать код для эффективного получения результатов выполненных задач.
С CompletionService это в значительной степени автоматизировано. Разница не очень очевидна в представленном вами коде, потому что вы отправляете только одну задачу. Однако представьте, что у вас есть список задач для отправки. В приведенном ниже примере несколько задач передаются в CompletionService. Затем, вместо того, чтобы попытаться выяснить, какая задача выполнена (чтобы получить результаты), он просто просит экземпляр CompletionService вернуть результаты по мере их появления.
public class CompletionServiceTest {
class CalcResult {
long result ;
CalcResult(long l) {
result = l;
}
}
class CallableTask implements Callable<CalcResult> {
String taskName ;
long input1 ;
int input2 ;
CallableTask(String name , long v1 , int v2 ) {
taskName = name;
input1 = v1;
input2 = v2 ;
}
public CalcResult call() throws Exception {
System.out.println(" Task " + taskName + " Started -----");
for(int i=0;i<input2 ;i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
System.out.println(" Task " + taskName + " Interrupted !! ");
e.printStackTrace();
}
input1 += i;
}
System.out.println(" Task " + taskName + " Completed @@@@@@");
return new CalcResult(input1) ;
}
}
public void test(){
ExecutorService taskExecutor = Executors.newFixedThreadPool(3);
CompletionService<CalcResult> taskCompletionService = new ExecutorCompletionService<CalcResult>(taskExecutor);
int submittedTasks = 5;
for (int i=0;i< submittedTasks;i++) {
taskCompletionService.submit(new CallableTask (
String.valueOf(i),
(i * 10),
((i * 10) + 10 )
));
System.out.println("Task " + String.valueOf(i) + "subitted");
}
for (int tasksHandled=0;tasksHandled<submittedTasks;tasksHandled++) {
try {
System.out.println("trying to take from Completion service");
Future<CalcResult> result = taskCompletionService.take();
System.out.println("result for a task availble in queue.Trying to get()");
// above call blocks till atleast one task is completed and results availble for it
// but we dont have to worry which one
// process the result here by doing result.get()
CalcResult l = result.get();
System.out.println("Task " + String.valueOf(tasksHandled) + "Completed - results obtained : " + String.valueOf(l.result));
} catch (InterruptedException e) {
// Something went wrong with a task submitted
System.out.println("Error Interrupted exception");
e.printStackTrace();
} catch (ExecutionException e) {
// Something went wrong with the result
e.printStackTrace();
System.out.println("Error get() threw exception");
}
}
}
}
Ответ 2
Опуская много деталей:
- ExecutorService = входящая очередь + рабочие потоки
- CompletionService = входящая очередь + рабочие потоки + очередь вывода
Ответ 3
Я думаю, что javadoc лучше всего отвечает на вопрос о том, когда CompletionService полезен способом ExecutorService.
Служба, которая отделяет выпуск новых асинхронных задач от потребления результатов выполненных задач.
В принципе, этот интерфейс позволяет программе создавать производителей, которые создают и представляют задачи (и даже анализируют результаты этих представлений), не зная о каких-либо других потребителях результатов этих задач. Между тем, потребители, которые знают о CompletionService, могут poll для или take получить результаты, не зная о производителях, отправляющих задачи.
Для записи, и я могу ошибаться, потому что это довольно поздно, но я уверен, что образец кода в этом сообщении в блоге вызывает утечку памяти. Без активного пользователя, берущего результаты из внутренней очереди ExecutorCompletionService, я не уверен, как блоггер ожидал, что очередь будет стекать.
Ответ 4
В основном вы используете CompletionService, если хотите выполнить несколько задач параллельно, а затем работать с ними в порядке их завершения. Итак, если я выполняю 5 заданий, CompletionService даст мне первый, который заканчивается. Пример, где есть только одна задача, не дает дополнительного значения над Executor, кроме возможности отправить Callable.
Ответ 5
Прежде всего, если мы не хотим тратить процессорное время, мы не будем использовать
while (!future.isDone()) {
// Do some work...
}
Мы должны использовать
service.shutdown();
service.awaitTermination(14, TimeUnit.DAYS);
Плохая вещь в этом коде заключается в том, что он отключит ExecutorService. Если мы хотим продолжить работу с ним (т.е. У нас есть какое-то рекурсивное создание задачи), у нас есть две альтернативы: invokeAll или ExecutorService.
invokeAll будет ждать, пока все задачи не будут завершены. ExecutorService предоставляет нам возможность поочередно брать результаты опроса.
И, конечно, рекурсивный пример:
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_NUMBER);
ExecutorCompletionService<String> completionService = new ExecutorCompletionService<String>(executorService);
while (Tasks.size() > 0) {
for (final Task task : Tasks) {
completionService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return DoTask(task);
}
});
}
try {
int taskNum = Tasks.size();
Tasks.clear();
for (int i = 0; i < taskNum; ++i) {
Result result = completionService.take().get();
if (result != null)
Tasks.add(result.toTask());
}
} catch (InterruptedException e) {
// error :(
} catch (ExecutionException e) {
// error :(
}
}
Ответ 6
Посмотрите это самостоятельно во время выполнения, попробуйте реализовать оба решения (Executorservice и Completionservice), и вы увидите, как они себя ведут, и будет более понятным, когда использовать тот или иной.
Здесь есть пример, если вы хотите http://rdafbn.blogspot.co.uk/2013/01/executorservice-vs-completionservice-vs.html
Ответ 7
Скажем, у вас есть 5 длинных задач (вызываемая задача), и вы передали эту задачу службе executer. Теперь представьте, что вы не хотите ждать, пока все 5 задач будут соревноваться, вместо этого вы хотите сделать какую-то обработку по этой задаче, если она будет завершена. Теперь это можно сделать либо путем написания логики опроса на будущих объектах, либо с помощью этого API.
Ответ 8
Если создатель задачи не заинтересован в результатах и ответственность за обработку результатов асинхронной задачи, выполняемой службой-исполнителем, лежит на другом компоненте, вам следует использовать CompletionService. Это поможет вам отделить обработчик результата задачи от производителя задачи. Смотрите пример http://www.zoftino.com/java-concurrency-executors-framework-tutorial
Ответ 9
есть еще одно преимущество использования сервиса завершения: производительность
когда вы вызываете future.get(), вы ожидаете вращения:
от java.util.concurrent.CompletableFuture
private Object waitingGet(boolean interruptible) {
Signaller q = null;
boolean queued = false;
int spins = -1;
Object r;
while ((r = result) == null) {
if (spins < 0)
spins = (Runtime.getRuntime().availableProcessors() > 1) ?
1 << 8 : 0; // Use brief spin-wait on multiprocessors
else if (spins > 0) {
if (ThreadLocalRandom.nextSecondarySeed() >= 0)
--spins;
}
когда у вас есть долгосрочное задание, это будет катастрофой для производительности.
В случае завершения обслуживания, когда задача будет выполнена, ее результат будет поставлен в очередь, и вы сможете опрашивать очередь с более низкой производительностью.
завершение обслуживания достичь этого с помощью задачи обтекания с done хуком.
java.util.concurrent.ExecutorCompletionService
private class QueueingFuture extends FutureTask<Void> {
QueueingFuture(RunnableFuture<V> task) {
super(task, null);
this.task = task;
}
protected void done() { completionQueue.add(task); }
private final Future<V> task;
}
Ответ 10
package com.barcap.test.test00;
import java.util.concurrent.*;
/**
* Created by Sony on 25-04-2019.
*/
public class ExecutorCompletest00 {
public static void main(String[] args) {
ExecutorService exc= Executors.newFixedThreadPool( 10 );
ExecutorCompletionService executorCompletionService= new ExecutorCompletionService( exc );
for (int i=1;i<10;i++){
Task00 task00= new Task00( i );
executorCompletionService.submit( task00 );
}
for (int i=1;i<20;i++){
try {
Future<Integer> future= (Future <Integer>) executorCompletionService.take();
Integer inttest=future.get();
System.out.println(" the result of completion service is "+inttest);
break;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}
================================================== =====
package com.barcap.test.test00;
import java.util.*;
import java.util.concurrent.*;
/**
* Created by Sony on 25-04-2019.
*/
public class ExecutorServ00 {
public static void main(String[] args) {
ExecutorService executorService=Executors.newFixedThreadPool( 9 );
List<Future> futList= new ArrayList <>( );
for (int i=1;i<10;i++) {
Future result= executorService.submit( new Task00( i ) );
futList.add( result );
}
for (Future<Integer> futureEach :futList ){
try {
Integer inm= futureEach.get();
System.out.println("the result of future executorservice is "+inm);
break;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}
================================================== =========
package com.barcap.test.test00;
import java.util.concurrent.*;
/**
* Created by Sony on 25-04-2019.
*/
public class Task00 implements Callable<Integer> {
int i;
public Task00(int i) {
this.i = i;
}
@Override
public Integer call() throws Exception {
System.out.println(" the current thread is "+Thread.currentThread().getName() +" the result should be "+i);
int sleepforsec=100000/i;
Thread.sleep( sleepforsec );
System.out.println(" the task complted for "+Thread.currentThread().getName() +" the result should be "+i);
return i;
}
}
================================================== ====================
разница в журналах для службы завершения исполнителя: текущий поток - пул-1-нить-1, результат должен быть равен 1, текущий поток - пул-1-нить-2, результат должен быть равен 2, текущий поток - пул-1-нить- 3 результат должен быть 3 текущий поток - пул-1-нить-4 результат должен быть 4 текущий поток - пул-1-нить-6 результат должен быть 6 текущий поток - пул-1-нить-5 результат должен быть 5 текущим потоком является pool-1-thread-7 результат должен быть 7 текущим потоком является pool-1-thread-9 результат должен быть 9 текущим потоком является pool-1-thread-8 результат должен Если 8 - задача выполнена для пула-1-нить-9, то результат должен быть 9, а результат - 9 - Задача выполнена для пула-1-нить-8. Результат должен быть 8 - Задача выполнена для пула-1-нить-7. результат должен быть 7 задача выполнена для пула-1-поток-6 результат должен быть 6 задача выполнена для пула-1-поток-5 результат должен быть 5 задача выполнена для пула-1-поток-4 результат должен быть 4 задача выполнена для пула-1-нить-3 результат должен быть 3
задача выполнена для пула-1-нить-2 результат должен быть 2
текущий поток - пул-1-нить-1, результат должен быть равен 1, текущий поток - пул-1-нить-3, результат должен быть 3, текущий поток - пул-1-нить-2, результат должен быть равен 2 текущий thread это pool-1-thread-5 результат должен быть 5 текущий поток это pool-1-thread-4 результат должен быть 4 текущий поток это pool-1-thread-6 результат должен быть 6 текущий поток pool-1-thread-7 результат должен быть 7 текущий поток - pool-1-thread-8 результат должен быть 8 текущий поток - pool-1-thread-9 результат должен быть 9 задача выполнена для pool- 1-thread-9 результат должен быть 9 задача выполнена для pool-1-thread-8 результат должен быть 8 задача завершена для pool-1-thread-7 результат должен быть 7 задача выполнена для pool-1- нить-6 результат должен быть 6 задача выполнена для пула-1-нить-5 результат должен быть 5 задача выполнена для пула-1-нить-4 результат должен быть 4 задача выполнена для пула-1-нить- 3 результат должен быть 3 задача выполнена для ol-1-thread-2 результат должен быть 2 задача выполнена для pool-1-thread-1 результат должен быть 1 результат будущем равен 1
================================================== =====
для executorservice результат будет доступен после выполнения всех задач.
executor completeservice любой результат, который можно получить, сделать это возвращение.
