java Executors工具类的相关方法使用创建

目录

• 通过Executors类创建线程池
• newCachedThreadPool方法
• newFixThreadPool方法
• newScheduledThreadPool方法
• newSingleThreadExecutor方法
• newSingleThreadScheduledExecutor方法
• newWorkStealingPool方法

通过Executors类创建线程池

线程池的创建方式有很多种，可以通过Executors工具类创建多种模式的线程池，Executors工具类位于java.util.concurrent.locks包中，接下来解释其中的方法。

首先将线程池的七个参数标在这里： corePoolSize：表示线程池中核心线程的数量；

maximumPoolSize：表示线程池中最大线程数量；

keepAliveTime：针对救急线程的存活时间的变量，就是当线程数量超过线程池中的核心数量时，如果没有新的任务被提交，那么核心线程外的救急线程就会保持在keepAliveTime变量值之后被销毁，而不是立即销毁；

unit：也是针对救急线程，表示keepAliveTime的核心单位；

workQueue：表示线程池中的阻塞队列，阻塞队列中存储着等待执行的任务；

threadFactory：表示用来创建线程的线程工厂。创建线程池的时候，默认的线程工厂创建的线程具有相同的优先级，可以为线程起一个好名字；

handler：表示线程池的拒绝策略。当线程池中的阻塞队列满了的时候，线程数maximumPoolSize也达到了最大值，如果此时再有任务提交到线程池，线程池就会采取策略来拒绝任务的执行。

newCachedThreadPool方法

调用Executors工具类的newCachedThreadPool方法可以创建一个可缓存的线程池，核心线程数为0，当线程池中的线程数量超过了运行任务所需要的线程数，那么可以回收空闲的线程，默认每60s回收；同时当任务增加的时候，线程池又可以创建新的线程来处理任务。

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue(),
                                      threadFactory);
    }

newFixThreadPool方法

调用Executors工具类的newFixThreadPool方法可以创建一个固定长度大小的线程池，线程池中的线程都是核心线程，也就是创建的线程池中的线程数量是固定的，能够控制线程池的最大并发数。

当向线程池提交任务时，如果线程池中有空闲的线程则会直接执行任务，如果没有空闲线程则会将任务放入阻塞队列中等待，有空闲线程的时候再去执行阻塞队列中的线程。

当线程池达到最大线程数时，线程数量会保持不变，一旦某个线程出现异常，线程池会补充一个线程。提交到线程池的任务过多可能会导致内存溢出。

    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue(),
                                      threadFactory);
    }

newScheduledThreadPool方法

调用Executors工具类的newScheduledThreadPool方法可以创建一个可以周期性执行任务的线程池，也能够定时执行任务。

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

newSingleThreadExecutor方法

调用Executors工具类的newSingleThreadExecutor方法可以创建只有一个工作线程的线程池，相当于只有一个线程在工作。能够保证任务按照先进先出的顺序，或者优先级顺序执行任务。就像单线程在串行执行任务一样，但是也有些区别，如果这个唯一的线程出现了异常，线程池会创建一个新的线程来代替它。

   public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue(),
                                    threadFactory));
    }

newSingleThreadScheduledExecutor方法

调用Executors工具类的newSingleThreadScheduledExecutor方法可以创建只有一个工作线程，并且支持定时，周期性执行任务的线程池。

    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
    }

newWorkStealingPool方法

调用Executors工具类的newSingleThreadExecutor方法可以创建一个具有并行级别的线程池，这是jdk 1.8新增的方法，可以为线程池设置并行级别，通过使用多个队列来减少竞争，需要传递一个并行级别的参数。

    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

以上就是java Executors工具类的相关方法使用创建的详细内容，更多关于java Executors工具类的资料请关注脚本之家其它相关文章！