java executor Java 线程池 ThreadPoolExecutor 的使用

java executor Java 线程池 ThreadPoolExecutor 的使用

引言

JAVA 语言为我们提供了两种基础线程池的选择：

它们都实现了 接口

注意，接口本身和“线程池”并没有直接关系，它的定义更接近“执行器”，而“使用线程管理的方式进行实现”只是其中的一种实现方式。

这里重点来看 类的使用，至于 类无非就是在 类基础上增加了定时调度功能。

构造器

提供了四个构造方法：

我们以最后一个构造方法（参数最多的那个），对其参数进行解释：

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

知道了各个参数的作用后，我们开始构造符合我们期待的线程池。

自定义线程池

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException, IOException {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue workQueue = new ArrayBlockingQueue(2);
        ThreadFactory threadFactory = new NameTreadFactory();
        RejectedExecutionHandler handler = new MyIgnorePolicy();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, threadFactory, handler);
        executor.prestartAllCoreThreads(); // 预启动所有核心线程
        
        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }
        System.in.read(); //阻塞主线程
    }
    static class NameTreadFactory implements ThreadFactory {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }
    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            doLog(r, e);
        }
        private void doLog(Runnable r, ThreadPoolExecutor e) {
            // 可做日志记录等
            System.err.println( r.toString() + " rejected");
//          System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
        }
    }
    static class MyTask implements Runnable {
        private String name;
        public MyTask(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                Thread.sleep(3000); //让任务执行慢点
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public String getName() {
            return name;
        }
        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

在上面的代码中，我们创建线程池的时候使用了 中最复杂的一个构造器

逻辑结构

一定要注意一个概念，即存在于线程池容器中的一定是 线程对象，而不是您要求运行的任务（所以叫线程池而不叫任务池也不叫对象池，更不叫游泳池）；您要求运行的任务将被线程池分配给某一个空闲的 线程对象运行。

从上图中，我们可以看到构成线程池的几个重要元素：

工作流程

首先您可以通过线程池提供的()方法或者()方法java executor Java 线程池 ThreadPoolExecutor 的使用，要求线程池执行某个任务。线程池收到这个要求执行的任务后，会有几种处理情况：

1.1、如果当前线程池中运行的线程数量还没有达到大小时，线程池会创建一个新的线程运行您的任务，无论之前已经创建的线程是否处于空闲状态。

1.2、如果当前线程池中运行的线程数量已经达到设置的大小，线程池会把您的这个任务加入到等待队列中。直到某一个的线程空闲了，线程池会根据您设置的等待队列规则，从队列中取出一个新的任务执行。

1.3、如果根据队列规则，这个任务无法加入等待队列。这时线程池就会创建一个“非核心线程”直接运行这个任务。注意，如果这种情况下任务执行成功，那么当前线程池中的线程数量一定大于。

1.4、如果这个任务，无法被“核心线程”直接执行，又无法加入等待队列，又无法创建“非核心线程”直接执行，且您没有为线程池设置dler。这时线程池会抛出异常，即线程池拒绝接受这个任务。（实际上抛出异常的操作，是线程池中一个默认的dler实现：，这在后文会提到）

一旦线程池中某个线程完成了任务的执行，它就会试图到任务等待队列中拿去下一个等待任务（所有的等待任务都实现了接口，按照接口字面上的理解，这是一个可阻塞的队列接口），它会调用等待队列的poll()方法，并停留在哪里。

当线程池中的线程超过您设置的参数，说明当前线程池中有所谓的“非核心线程”。那么当某个线程处理完任务后，如果等待时间后仍然没有新的任务分配给它，那么这个线程将会被回收。线程池回收线程时，对所谓的“核心线程”和“非核心线程”是一视同仁的java executor，直到线程池中线程的数量等于您设置的参数时java executor，回收过程才会停止。

不常用的设置

在 线程池中，有一些不常用的设置。我建议如果您在应用场景中没有特殊的要求，就不需要使用这些设置

ut

前文我们讨论到，线程池回收线程只会发生在当前线程池中线程数量大于 参数的时候；当线程池中线程数量小于等于 参数的时候，回收过程就会停止。

ut 设置项可以要求线程池：将包括“核心线程”在内的，没有任务分配的任何线程，在等待时间后全部进行回收：

ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 1, TimeUnit.MINUTES, new ArrayBlockingQueue(1));
poolExecutor.allowCoreThreadTimeOut(true);

ds

前文我们还讨论到java executor Java 线程池 ThreadPoolExecutor 的使用，当线程池中的线程还没有达到您设置的参数值的时候，如果有新的任务到来，线程池将创建新的线程运行这个任务，无论之前已经创建的线程是否处于空闲状态。

ds设置项，可以在线程池创建java executor，但还没有接收到任何任务的情况下，先行创建符合 参数值的线程数：

ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 1, TimeUnit.MINUTES, new ArrayBlockingQueue(1));
poolExecutor.prestartAllCoreThreads();

总结

如果 Java 内置的四种线程池 、、ol、tor 仍然无法满足实际场景需要时，则需要通过自定义线程池，让线程池更好的满足我们的需求。