这篇文章主要介绍“Java线程池的用法”，在日常操作中，相信很多人在Java线程池的用法问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java线程池的用法”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

ThreadPoolExecutor

ThreadPoolExecutor是Java线程池中最核心的一个类。

public interface Executor {
    void execute(Runnable command);
}
public interface ExecutorService implements Executor {}
public abstract class AbstractExecutorService implements ExecutorService {}
public class ThreadPoolExecutor extends AbstractExecutorService {
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
}

corePoolSize

核心线程池的大小

maximumPoolSize

线程池允许执行的最大线程数量，当超过这个数量后，任务将存放在workQueue中。

keepAliveTime

当线程池中线程数量大于核心线程池大小时，线程执行完之后就会销毁掉，直到线程池数量不超过核心线程池大小。

unit

keepAliveTime的单位，常见的有DAYS、HOURS、MINUTES、SECONDS、MILLISECONDS、MICROSECONDS、NANOSECONDS

workQueue

阻塞队列，用于存储等待执行的任务。一般有以下几种选择

ArrayBlockingQueue

有界队列，当有新任务到来时 当实际线程数小于corePoolSize时，线程池会生成新的线程执行任务； 当实际线程数大于corePoolSize时，新任务就会加入等待队列，当等待队列满的时候，则会在实际线程不大于maximumPoolSize的前提下创建新线程去处理任务。

LinkedBlockingQueue

无界任务队列，当有新任务到来时 当实际线程数小于corePoolSize时，线程池会生成新的线程执行任务，当实际线程数大于corePoolSize时，新任务就会加入等待队列。如果创建速度大于处理速度，则队列会一直增长，直到耗尽内存。

SynchronousQueue

直接提交的队列，当有新任务到来时 当实际线程数小于maximumPoolSize时，线程池会生成新的线程执行任务； 当实际线程数大于maximumPoolSize时，新任务就会加入等待队列，但队列只会保存最新提交的一个任务。

threadFactory

用来创建线程的工厂

handler

表示拒绝处理任务的策略，有以下取值

ThreadPoolExecutor.AbortPolicy //丢弃任务并抛出RejectedExecutionException异常
ThreadPoolExecutor.DiscardPolicy //也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy //丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy //由调用线程处理该任务

预创建线程池

ExecutorService newCachedThreadPool()

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

无界线程池，最大线程池为Integer的最大值，线程过大时可能导致OOM。

ExecutorService newFixedThreadPool()

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

固定大小的线程池。线程数量外部传入

ExecutorService newSingleThreadExecutor()

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

单一线程池

到此，关于“Java线程池的用法”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注天达云网站，小编会继续努力为大家带来更多实用的文章！