grupo de subprocesos java newWorkStealingPool

• Cómo se implementa el hilo

  • Java multiproceso extiende el subproceso

  • Implementos Java multiproceso Runnable

  • Implementos Java multiproceso invocables

• Uso de grupo de subprocesos

  • Introducción a los grupos de subprocesos

  • ThreadPoolExecutor

    • grupo de subprocesos java newScheduledThreadPool

    • grupo de subprocesos java newCachedThreadPool

    • grupo de subprocesos java newFixedThreadPool

    • grupo de subprocesos java newSingleThreadExecutor

  • HorquillaUnirsePiscina

    • grupo de subprocesos java newWorkStealingPool 

 newWorkStealingPool es adecuado para operaciones que consumen mucho tiempo, pero newWorkStealingPool no es una extensión de ThreadPoolExecutor, es una extensión de la nueva clase de grupo de subprocesos ForkJoinPool, pero se implementa en una clase Executors unificada, porque puede usar razonablemente la CPU para operaciones de tareas (Funcionamiento en paralelo), por lo que es adecuado para su uso en tareas que requieren mucho tiempo:

Código de muestra:

public class WorkStealingPoolTest {
    // 线程数
    private static final int threads = 10;
    // 用于计数线程是否执行完成
    CountDownLatch countDownLatch = new CountDownLatch(threads);

    /**
     * newFixedThreadPool execute
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test1() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < threads; i++) {
            executorService.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName());
                } catch (Exception e) {
                    System.out.println(e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }

    /**
     * newFixedThreadPool submit submit
     */
    @Test
    public void test2() throws InterruptedException {
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < threads; i++) {
//            Callable 带返回值
            executorService.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        countDownLatch.countDown();
                    }
                }
            }));
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }

    /**
     * newFixedThreadPool submit Callable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test3() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < threads; i++) {
//          Runnable 带返回值
            FutureTask<?> futureTask = new FutureTask<>(new Callable<String>() {
                /**
                 * call
                 * @return currentThreadName
                 */
                @Override
                public String call() {
                    return Thread.currentThread().getName();
                }
            });
            executorService.submit(new Thread(futureTask));
            System.out.println(futureTask.get());
        }
        System.out.println("---- end ----");
    }
}