    private Executors() {
    }
    
    
    
    /*▼ 【工作池】 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * Creates a work-stealing thread pool using the number of
     * {@linkplain Runtime#availableProcessors available processors}
     * as its target parallelism level.
     *
     * @return the newly created thread pool
     *
     * @see #newWorkStealingPool(int)
     * @since 1.8
     */
    // 并行度与处理器数量相同的【工作池】
    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool(Runtime.getRuntime().availableProcessors(), ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
    }
    
    /**
     * Creates a thread pool that maintains enough threads to support
     * the given parallelism level, and may use multiple queues to
     * reduce contention. The parallelism level corresponds to the
     * maximum number of threads actively engaged in, or available to
     * engage in, task processing. The actual number of threads may
     * grow and shrink dynamically. A work-stealing pool makes no
     * guarantees about the order in which submitted tasks are
     * executed.
     *
     * @param parallelism the targeted parallelism level
     *
     * @return the newly created thread pool
     *
     * @throws IllegalArgumentException if {@code parallelism <= 0}
     * @since 1.8
     */
    // 并行度为parallelism的【工作池】
    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool(parallelism, ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
    }
    
    /*▲ 【工作池】 ██████████████████████████████████████████████████████████�