【Java编程的逻辑】线程池_java 线程池能用 static final 修饰吗-优快云博客

本文链接：https://blog.youkuaiyun.com/u013435893/article/details/80226029

基本介绍

线程池，顾名思义，就是一个线程的池子，里有若干线程，它们的目的就是执行提交给线程池的任务，执行完一个任务后不会退出，而是继续等待或执行新的任务。

线程池的优点：

可以重用线程，避免线程创建的开销
任务过多时，通过排序避免创建过多线程，减少系统资源消耗和竞争，确任务有序完成

ThreadPoolExecutor

Java并发包中线程池的实现类是ThreadPollExecutor，它继承了AbstractExecutorService，AbstractExecutorService实现了ExecutorService

我们先看看ThreadPoolExecutor的主要构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

我们先谈谈这些参数

线程池大小

corePoolSize
maximumPoolSize
keepAliveTime 和 unit

corePollSize表示线程池中的核心线程个数，并不是一开始就创建这么多线程，默认情况下，刚创建一个线程池后并不会创建任何线程。线程个数小于等于corePoolSize时，我们称这些线程为核心线程

maximumPoolSize表示线程池中的最多线程数，线程的个数会动态变化，但都不会创建比这个值大的线程个数

一般情况下，新任务到来的时候，如果当前线程个数小于corePoolSize，就会创建一个新线程来执行该任务，即使其他线程现在也是空闲的。如果线程个数大于等于corePoolSize，那就不会立即创建新线程，而是先尝试排队，如果队列满了或其他原因不能立即入队，它就不会排队，而是检查线程个数是否达到了maximumPoolSize，如果没有，就会创建线程。

keepAliveTime表示当线程池中线程个数大于corePoolSize时额外空闲线程的存活时间。也就是说，一个非核心线程，在空闲等待新任务时，会有一个最长等待时间（keepAliveTime），如果到了时间还没有新任务，就会被终止。如果该值为0，则表示所有线程都不会超时终止。

默认情况下：核心线程不会预先创建，只有当有任务时才会创建；核心线程不会因为空闲而被终止。
不过ThreadPoolExecutor可以改变这个默认行为

// 预先创建所有的核心线程
public int prestartAllCoreThreads();
// 创建一个核心线程，如果所有核心线程都已创建，返回false
public boolean prestartCoreThread();
// 如果设置为true，则keepAliveTime参数也适用于核心线程
public void allowCoreThreadTimeout(boolean value);

队列

ThreadPoolExecutor要求队列类型是阻塞队列BlockingQueue。
在介绍并发容器的时候了解过几种阻塞队列：

LinkedBlockingQueue：基于链表的阻塞队列，可以指定最大长度，但默认是无界的
ArrayBlockingQueue：基于数组的有界阻塞队列
PriorityBlockingQueue：基于堆的无界阻塞队列
SynchronousQueue：没有实际存储空间的同步阻塞队列

拒绝策略

如果队列有界，且maximumPoolSize有限，则当队列排满，线程个数也达到了maximumPoolSize时，新任务来了，就会触发线程池的任务拒绝策略
ThreadPoolExecutor实现了4种处理方法：
1. ThreadPoolExecutor.AbortPolicy：这是默认的方式，抛出异常RejectedExecutionException
2. ThreadPoolExecutor.DiscardPolicy：忽略新任务，不抛出异常，也不执行
3. ThreadPoolExecutor.DiscardOldestPolicy：将等待时间最长的任务扔掉，然后排队
4. ThreadPoolExecutor.CallerRunsPolicy：在任务提交者线程中执行任务，而不是交给线程池中的线程执行

它们都是ThreadPoolExecutor的内部类，实现了RejectedExecutionHandler接口

public interface RejectedExecutionHandler { 
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

线程工厂

还有一个参数：ThreadFactory。它是一个接口

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

这个接口根据Runnable创建一个Thread。
ThreadPoolExecutor的默认实现是Executors类中的静态内部类DefaultThreadFacotry，主要就是创建一个线程，给线程设置名字，设置daemon属性为false，设置线程优先级为标准默认优先级，线程名字格式为：pool-<线程池编号>-thread-<线程编号>

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

工厂类Executors

类Executors提供了一些静态工程方法，可以方便地创建一些预配置的线程池

newSingleThreadExecutor

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

只使用一个线程，使用无界的LinkedBlockingQueue，线程创建后不会超时终止，该线程顺序执行所有任务。该线程适用于需要确保所有任务被顺序执行的场合

newFixedThreadPool

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

使用固定数目的n个线程，使用无界LinkedBlockingQueue，线程创建后不会超时终止，由于是无界队列，如果排队任务过多，会消耗过多的内存。

newCachedThreadPool

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

corePoolSize为0，maximumPoolSize为Integer.MAX_VALUE，keepAliveTime是60秒，队列为SynchronousQueue。
当新任务来的时候，如果正好有空闲线程在等待任务，则其中一个空闲线程接受该任务，否则就总是创建一个新的线程，创建的总线程个数不受限制，对于空闲线程，如果60秒内没有新任务就终止