Есть ли основания использовать `forkjoinpool/` expertors.newworkstealingpool () `без реализации рецирсивистирования/реци ⇐ JAVA

[Anonymous]

В предыдущей теме я обнаружил, что моя задача является хорошим кандидатом на FJP/Executors.newWorkStealingPool ()
Позвольте мне напомнить базу кода (это искусственный код, который продемонстрировал моя настоящая проблема): < /p>

Код: Выделить всё

fun main(args: Array) {
val start = System.currentTimeMillis()
Internal().doWork()
println("Duration is ${(System.currentTimeMillis() - start)/1000} sec")
}

class Internal {

fun doWork() {

val pool = ThreadPoolExecutor(
3, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
ArrayBlockingQueue(1000),
)

val future = CompletableFuture.supplyAsync(
{
// 1 subtask
val future1 = CompletableFuture.supplyAsync(
{
(1..10).map {
CompletableFuture.supplyAsync(SingleExternalCall(), pool)
}.sumOf { it.join() }
},
pool,
)
// 2 subtask
val future2 = CompletableFuture.supplyAsync(
{
(1..5).map {
CompletableFuture.supplyAsync(SingleExternalCall(), pool)
}.sumOf { it.join() }
},
pool,
)
// aggregate
future1.join() + future2.join()
},
pool,
)
println(future.join())
}

class SingleExternalCall : Supplier {

override fun get(): Int {
Thread.sleep(5000)
return counter.incrementAndGet().toInt()
}
}

Позвольте мне предоставить несколько аргументов:

В большинстве учебных пособий об авторах FJP реализует рецирсивиакция/recurusivetask и Тогда сделайте SMTH

Код: Выделить всё

  MyRecursiveTask myRecursiveTask = new MyRecursiveTask(128);
long mergedResult = forkJoinPool.invoke(myRecursiveTask);
System.out.println("mergedResult = " + mergedResult);

Уловка здесь, который Recurrusivetask знает, как оценить, если задача достаточно, чтобы выполнить на месте, и иначе разделить для меньших задач:

Код: Выделить всё

public class MyRecursiveTask extends RecursiveTask {

private long workLoad = 0;

public MyRecursiveTask(long workLoad) {
this.workLoad = workLoad;
}

protected Long compute() {

//if work is above threshold, break tasks up into smaller tasks
if(this.workLoad > 16) {
System.out.println("Splitting workLoad : " + this.workLoad);

long workload1 = this.workLoad / 2;
long workload2 = this.workLoad - workload1;

MyRecursiveTask subtask1 = new MyRecursiveTask(workload1);
MyRecursiveTask subtask2 = new MyRecursiveTask(workload2);

subtask1.fork();
subtask2.fork();

long result = 0;
result += subtask1.join();
result += subtask2.join();
return result;

} else {
System.out.println("Doing workLoad myself: " + this.workLoad);
return workLoad * 3;
}
}
}
< /code>

 executorservice.newWorkStealingPool () == forkjoinpool < /li>
< /ol>
public static ExecutorService.newWorkStealingPool() {
return new ForkJoinPool
(Runtime.getRuntime().availableProcessors(),
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}
< /code>
Итак, мой вопрос: < /p>
Есть ли причина использовать код, подобный этому? < /p>
    var wsp= ExecutorService.newWorkStealingPool()
CompletableFuture.supplyAsync({
//some code without using RecursiveAction/Task
}, wsp)
< /code>
будет отличаться от < /p>
    var pool = ExecutorService.newWorkStealingPool()
CompletableFuture.supplyAsync({
//some code without using RecursiveAction/Task
}, cachedThreadPool)
< /code>
?pool.submit(someCallable)
< /code>
? Но у них также нет рецирсивистического/задания 

, поэтому я не понимаю, почему FJP был выбран для потокового API.

Подробнее здесь: https://stackoverflow.com/questions/793 ... -without-i