1. 线程池的创建

线程池的创建使用ThreadPoolExecutor类，有利于编码时更好的明确线程池运行规则。

     //构造函数

         /**

     * Creates a new {@code ThreadPoolExecutor} with the given initial

     * parameters.

     *

     * @param corePoolSize the number of threads to keep in the pool, even

     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set

     * @param maximumPoolSize the maximum number of threads to allow in the

     *        pool

     * @param keepAliveTime when the number of threads is greater than

     *        the core, this is the maximum time that excess idle threads

     *        will wait for new tasks before terminating.

     * @param unit the time unit for the {@code keepAliveTime} argument

     * @param workQueue the queue to use for holding tasks before they are

     *        executed.  This queue will hold only the {@code Runnable}

     *        tasks submitted by the {@code execute} method.

     * @param threadFactory the factory to use when the executor

     *        creates a new thread

     * @param handler the handler to use when execution is blocked

     *        because the thread bounds and queue capacities are reached

     * @throws IllegalArgumentException if one of the following holds:<br>

     *         {@code corePoolSize < 0}<br>

     *         {@code keepAliveTime < 0}<br>

     *         {@code maximumPoolSize <= 0}<br>

     *         {@code maximumPoolSize < corePoolSize}

     * @throws NullPointerException if {@code workQueue}

     *         or {@code threadFactory} or {@code handler} is null

     */

    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.corePoolSize = corePoolSize;

        this.maximumPoolSize = maximumPoolSize;

        this.workQueue = workQueue;

        this.keepAliveTime = unit.toNanos(keepAliveTime);

        this.threadFactory = threadFactory;

        this.handler = handler;

    }

参数含义

(1) 核心线程数corePoolSize：保持在池中的线程数

(2) 最大线程数maximumPoolSize

(3) 保活时间keepAliveTime：线程数大于corePoolSize，闲置线程最大空闲时间

(4) 时间单位unit

(5) 阻塞队列workQueue

java.util.concurrent.BlockingQueue主要实现类有：

ArrayBlockingQueue：数组结构有界阻塞队列，FIFO排序。其构造函数必须设置队列长度。
LinkedBlockingQueue：链表结构有界阻塞队列，FIFO排序。队列默认最大长度为Integer.MAX_VALUE,故可能会堆积大量请求，导致OOM。
PriorityBlockingQueue：支持优先级排序的无界阻塞队列。默认自然顺序排列，可以通过比较器comparator指定排序规则。
DelayQueue：支持延时获取元素的无界阻塞队列。队列使用PriorityQueue实现。

(6) 线程创建接口threadFactory

默认使用Executors.defaultThreadFactory()。
可以自定义ThreadFactory实现或使用第三方实现，方便指定有意义的线程名称。

import com.google.common.util.concurrent.ThreadFactoryBuilder;

    ...

    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("my-pool-%d").build();

public class MyThreadFactory implements ThreadFactory {

    private final AtomicInteger threadNumber = new AtomicInteger(1);

    private final String namePrefix;

    MyThreadFactory(String namePrefix) {

        this.namePrefix = namePrefix+"-";

    }

    @Override

    public Thread newThread(Runnable r) {

        Thread t = new Thread( r,namePrefix + threadNumber.getAndIncrement());

        if (t.isDaemon()) {

            t.setDaemon(true);

        }

        if (t.getPriority() != Thread.NORM_PRIORITY) {

            t.setPriority(Thread.NORM_PRIORITY);

        }

        return t;

    }

}

(7) 饱和策略handler

ThreadPoolExecutor.AbortPolicy()：终止策略(默认) ，抛出java.util.concurrent.RejectedExecutionException异常。
ThreadPoolExecutor.CallerRunsPolicy(): 重试添加当前的任务，他会自动重复调用execute()方法。
ThreadPoolExecutor.DiscardOldestPolicy(): 抛弃下一个即将被执行的任务，然后尝试重新提交新的任务。最好不和优先级队列一起使用，因为它会抛弃优先级最高的任务。
ThreadPoolExecutor.DiscardPolicy(): 抛弃策略，抛弃当前任务。

2. 线程池的运行规则

execute添加任务到线程池:

一个任务通过execute(Runnable)方法被添加到线程池。任务是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

线程池运行规则:

当一个任务通过execute(Runnable)方法添加到线程池时：

如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
也就是：处理任务的优先级为：

核心线程corePoolSize - > 任务队列workQueue - > 最大线程maximumPoolSize

如果三者都满了，使用handler策略处理该任务。

当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

    // execute方法源码实现(jdk1.8)

    public void execute(Runnable command) {

        if (command == null)

            throw new NullPointerException();

        /*

         * Proceed in 3 steps:

         *

         * 1. If fewer than corePoolSize threads are running, try to

         * start a new thread with the given command as its first

         * task.  The call to addWorker atomically checks runState and

         * workerCount, and so prevents false alarms that would add

         * threads when it shouldn't, by returning false.

         *

         * 2. If a task can be successfully queued, then we still need

         * to double-check whether we should have added a thread

         * (because existing ones died since last checking) or that

         * the pool shut down since entry into this method. So we

         * recheck state and if necessary roll back the enqueuing if

         * stopped, or start a new thread if there are none.

         *

         * 3. If we cannot queue task, then we try to add a new

         * thread.  If it fails, we know we are shut down or saturated

         * and so reject the task.

         */

        int c = ctl.get();

        if (workerCountOf(c) < corePoolSize) {

            if (addWorker(command, true))

                return;

            c = ctl.get();

        }

        if (isRunning(c) && workQueue.offer(command)) {

            int recheck = ctl.get();

            if (! isRunning(recheck) && remove(command))

                reject(command);

            else if (workerCountOf(recheck) == 0)

                addWorker(null, false);

        }

        else if (!addWorker(command, false))

            reject(command);

    }

3. 线程池的关闭

通过调用线程池的shutdown或shutdownNow方法来关闭线程池。

shutdown：将线程池的状态设置成SHUTDOWN状态，然后interrupt空闲线程。
shutdownNow：线程池的状态设置成STOP，然后尝试interrupt所有线程，包括正在运行的。

关于线程池状态，源码中的注释比较清晰：

再看一下源代码：

    // 在关闭中，之前提交的任务会被执行（包含正在执行的，在阻塞队列中的），但新任务会被拒绝。

    public void shutdown() {

        final ReentrantLock mainLock = this.mainLock;

        mainLock.lock();

        try {

            checkShutdownAccess();

            // 状态设置为shutdown

            advanceRunState(SHUTDOWN);

            // interrupt空闲线程

            interruptIdleWorkers();

            onShutdown(); // hook for ScheduledThreadPoolExecutor

        } finally {

            mainLock.unlock();

        }

        // 尝试终止线程池

        tryTerminate();

    }

其中，interruptIdleWorkers()方法往下调用了interruptIdleWorkers(), 这里w.tryLock()比较关键。

中断之前需要先tryLock()获取worker锁，正在运行的worker tryLock()失败(runWorker()方法会先对worker上锁)，故正在运行的worker不能中断。

    // 尝试停止所有正在执行的任务，停止对等待任务的处理，并返回正在等待被执行的任务列表

    public List<Runnable> shutdownNow() {

        List<Runnable> tasks;

        final ReentrantLock mainLock = this.mainLock;

        mainLock.lock();

        try {

            checkShutdownAccess();

            // 状态设置为STOP

            advanceRunState(STOP);

            // 停止所有线程  interruptWorkers逻辑简单些，循环对所有worker调用interruptIfStarted().(interrupt所有线程)

            interruptWorkers();

            tasks = drainQueue();

        } finally {

            mainLock.unlock();

        }

        tryTerminate();

        return tasks;

    }

4. 线程池的使用场合

（1）单个任务处理的时间比较短；

（2）需要处理的任务数量大；

5. 线程池大小的设置

可根据计算任务类型估算线程池设置大小：

cpu密集型：可采用Runtime.avaliableProcesses()+1个线程；

IO密集型：由于阻塞操作多，可使用更多的线程，如2倍cpu核数。

6 实现举例

场景: ftp服务器收到文件后，触发相关搬移/处理操作。

public class FtpEventHandler extends DefaultFtplet {

    @Override

    public FtpletResult onUploadEnd(FtpSession session, FtpRequest request)

            throws FtpException, IOException {

        // 获取文件名

        String fileName = request.getArgument();

        Integer index = fileName.lastIndexOf("/");

        String realFileName = fileName.substring(index + 1);

        index = realFileName.lastIndexOf("\\");

        realFileName = realFileName.substring(index + 1);

        // **处理文件**

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 50, 10,

                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3));

        threadPool.execute(new fileSenderThread(realFileName));

        return FtpletResult.DEFAULT;

    }

}

Spring也提供了ThreadPoolTaskExecutor

     <!--spring.xml配置示例-->

    <bean id="gkTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">

        <property name="allowCoreThreadTimeOut" value="true"/>

        <property name="corePoolSize" value="10"/>

        <property name="maxPoolSize" value="50"/>

        <property name="queueCapacity" value="3"/>

        <property name="keepAliveSeconds" value="10"/>

        <property name="rejectedExecutionHandler"

                  value="#{new java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy()}"/>

        <property name="threadNamePrefix" value="gkTaskExecutor"/>

    </bean>

    //java代码中注入bean

    @Autowired

    @Qualifier("gkTaskExecutor")

    private ThreadPoolTaskExecutor gkTaskExecutor;

end.

巴特西

java线程池的使用学习