跟着阿里p7一块儿学java高并发 - 第18天：玩转java线程池，这一篇就够了

时间 2020-02-10

标签跟着阿里 p7 一块儿 java 并发 18天线程一篇够了栏目阿里巴巴繁體版

原文原文链接

java高并发系列第18篇文章。java

本文主要内容

什么是线程池
线程池实现原理
线程池中常见的各类队列
自定义线程建立的工厂
常见的饱和策略
自定义饱和策略
线程池中两种关闭方法有何不一样
扩展线程池
合理地配置线程池
线程池中线程数量的配置

什么是线程池

你们用jdbc操做过数据库应该知道，操做数据库须要和数据库创建链接，拿到链接以后才能操做数据库，用完以后销毁。数据库链接的建立和销毁实际上是比较耗时的，真正和业务相关的操做耗时是比较短的。每一个数据库操做以前都须要建立链接，为了提高系统性能，后来出现了数据库链接池，系统启动的时候，先建立不少链接放在池子里面，使用的时候，直接从链接池中获取一个，使用完毕以后返回到池子里面，继续给其余须要者使用，这其中就省去建立链接的时间，从而提高了系统总体的性能。数据库

线程池和数据库链接池的原理也差很少，建立线程去处理业务，可能建立线程的时间比处理业务的时间还长一些，若是系统可以提早为咱们建立好线程，咱们须要的时候直接拿来使用，用完以后不是直接将其关闭，而是将其返回到线程中中，给其余须要这使用，这样直接节省了建立和销毁的时间，提高了系统的性能。数组

简单的说，在使用了线程池以后，建立线程变成了从线程池中获取一个空闲的线程，而后使用，关闭线程变成了将线程归还到线程池。缓存

线程池实现原理

当向线程池提交一个任务以后，线程池的处理流程以下：安全

判断是否达到核心线程数，若未达到，则直接建立新的线程处理当前传入的任务，不然进入下个流程
线程池中的工做队列是否已满，若未满，则将任务丢入工做队列中先存着等待处理，不然进入下个流程
是否达到最大线程数，若未达到，则建立新的线程处理当前传入的任务，不然交给线程池中的饱和策略进行处理。

流程以下图：微信

举个例子，加深理解：多线程

我们做为开发者，上面都有开发主管，主管下面带领几个小弟干活，CTO给主管受权说，你能够招聘5个小弟干活，新来任务，若是小弟还不到吴哥，当即去招聘一个来干这个新来的任务，当5个小弟都招来了，再来任务以后，将任务记录到一个表格中，表格中最多记录100个，小弟们会主动去表格中获取任务执行，若是5个小弟都在干活，而且表格中也记录满了，那你能够将小弟扩充到20个，若是20个小弟都在干活，而且存听任务的表也满了，产品经理再来任务后，是直接拒绝，仍是让产品本身干，这个由你本身决定，小弟们都全力以赴在干活，任务都被处理完了，忽然公司业绩下滑，几个员工没事干，打酱油，为了节约成本，CTO主管把小弟控制到5人，其余15我的直接被干掉了。因此做为小弟们，别让本身闲着，多干活。并发

原理：先找几我的干活，你们都忙于干活，任务太多能够排期，排期的任务太多了，再招一些人来干活，最后干活的和排期都达到上层领导要求的上限了，那须要采起一些其余策略进行处理了。对于长时间不干活的人，考虑将其开掉，节约资源和成本。框架

java中的线程池

jdk中提供了线程池的具体实现，实现类是：java.util.concurrent.ThreadPoolExecutor，主要构造方法：ide

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

corePoolSize：核心线程大小，当提交一个任务到线程池时，线程池会建立一个线程来执行任务，即便有其余空闲线程能够处理任务也会创新线程，等到工做的线程数大于核心线程数时就不会在建立了。若是调用了线程池的prestartAllCoreThreads方法，线程池会提早把核心线程都创造好，并启动

maximumPoolSize：线程池容许建立的最大线程数。若是队列满了，而且以建立的线程数小于最大线程数，则线程池会再建立新的线程执行任务。若是咱们使用了无界队列，那么全部的任务会加入队列，这个参数就没有什么效果了

keepAliveTime：线程池的工做线程空闲后，保持存活的时间。若是没有任务处理了，有些线程会空闲，空闲的时间超过了这个值，会被回收掉。若是任务不少，而且每一个任务的执行时间比较短，避免线程重复建立和回收，能够调大这个时间，提升线程的利用率

unit：keepAliveTIme的时间单位，能够选择的单位有天、小时、分钟、毫秒、微妙、千分之一毫秒和纳秒。类型是一个枚举java.util.concurrent.TimeUnit，这个枚举也常用，有兴趣的能够看一下其源码

workQueue：工做队列，用于缓存待处理任务的阻塞队列，常见的有4种，本文后面有介绍

threadFactory：线程池中建立线程的工厂，能够经过线程工厂给每一个建立出来的线程设置更有意义的名字

handler：饱和策略，当线程池没法处理新来的任务了，那么须要提供一种策略处理提交的新任务，默认有4种策略，文章后面会提到

调用线程池的execute方法处理任务，执行execute方法的过程：

判断线程池中运行的线程数是否小于corepoolsize，是：则建立新的线程来处理任务，否：执行下一步
试图将任务添加到workQueue指定的队列中，若是没法添加到队列，进入下一步
判断线程池中运行的线程数是否小于maximumPoolSize，是：则新增线程处理当前传入的任务，否：将任务传递给handler对象rejectedExecution方法处理

线程池的使用步骤：

调用构造方法建立线程池
调用线程池的方法处理任务
关闭线程池

线程池使用的简单示例

上一个简单的示例，以下：

package com.itsoku.chat16;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo1 {
    static ThreadPoolExecutor executor = new ThreadPoolExecutor(3,
            5,
            10,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            int j = i;
            String taskName = "任务" + j;
            executor.execute(() -> {
                //模拟任务内部处理耗时
                try {
                    TimeUnit.SECONDS.sleep(j);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + taskName + "处理完毕");
            });
        }
        //关闭线程池
        executor.shutdown();
    }
}

输出：

pool-1-thread-1任务0处理完毕
pool-1-thread-2任务1处理完毕
pool-1-thread-3任务2处理完毕
pool-1-thread-1任务3处理完毕
pool-1-thread-2任务4处理完毕
pool-1-thread-3任务5处理完毕
pool-1-thread-1任务6处理完毕
pool-1-thread-2任务7处理完毕
pool-1-thread-3任务8处理完毕
pool-1-thread-1任务9处理完毕

线程池中常见5种工做队列

任务太多的时候，工做队列用于暂时缓存待处理的任务，jdk中常见的5种阻塞队列：

ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按照先进先出原则对元素进行排序

LinkedBlockingQueue：是一个基于链表结构的阻塞队列，此队列按照先进先出排序元素，吞吐量一般要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool使用了这个队列。

SynchronousQueue ：一个不存储元素的阻塞队列，每一个插入操做必须等到另一个线程调用移除操做，不然插入操做一直处理阻塞状态，吞吐量一般要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用这个队列

PriorityBlockingQueue：优先级队列，进入队列的元素按照优先级会进行排序

前2种队列相关示例就不说了，主要说一下后面2种队列的使用示例。

SynchronousQueue队列的线程池

package com.itsoku.chat16;

import java.util.concurrent.*;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo2 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 50; i++) {
            int j = i;
            String taskName = "任务" + j;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "处理" + taskName);
                //模拟任务内部处理耗时
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executor.shutdown();
    }
}

pool-1-thread-1处理任务0
pool-1-thread-2处理任务1
pool-1-thread-3处理任务2
pool-1-thread-6处理任务5
pool-1-thread-7处理任务6
pool-1-thread-4处理任务3
pool-1-thread-5处理任务4
pool-1-thread-8处理任务7
pool-1-thread-9处理任务8
pool-1-thread-10处理任务9
pool-1-thread-11处理任务10
pool-1-thread-12处理任务11
pool-1-thread-13处理任务12
pool-1-thread-14处理任务13
pool-1-thread-15处理任务14
pool-1-thread-16处理任务15
pool-1-thread-17处理任务16
pool-1-thread-18处理任务17
pool-1-thread-19处理任务18
pool-1-thread-20处理任务19
pool-1-thread-21处理任务20
pool-1-thread-25处理任务24
pool-1-thread-24处理任务23
pool-1-thread-23处理任务22
pool-1-thread-22处理任务21
pool-1-thread-26处理任务25
pool-1-thread-27处理任务26
pool-1-thread-28处理任务27
pool-1-thread-30处理任务29
pool-1-thread-29处理任务28
pool-1-thread-31处理任务30
pool-1-thread-32处理任务31
pool-1-thread-33处理任务32
pool-1-thread-38处理任务37
pool-1-thread-35处理任务34
pool-1-thread-36处理任务35
pool-1-thread-41处理任务40
pool-1-thread-34处理任务33
pool-1-thread-39处理任务38
pool-1-thread-40处理任务39
pool-1-thread-37处理任务36
pool-1-thread-42处理任务41
pool-1-thread-43处理任务42
pool-1-thread-45处理任务44
pool-1-thread-46处理任务45
pool-1-thread-44处理任务43
pool-1-thread-47处理任务46
pool-1-thread-50处理任务49
pool-1-thread-48处理任务47
pool-1-thread-49处理任务48

代码中使用Executors.newCachedThreadPool()建立线程池，看一下的源码：

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

从输出中能够看出，系统建立了50个线程处理任务，代码中使用了SynchronousQueue同步队列，这种队列比较特殊，放入元素必需要有另一个线程去获取这个元素，不然放入元素会失败或者一直阻塞在那里直到有线程取走，示例中任务处理休眠了指定的时间，致使已建立的工做线程都忙于处理任务，因此新来任务以后，将任务丢入同步队列会失败，丢入队列失败以后，会尝试新建线程处理任务。使用上面的方式建立线程池须要注意，若是须要处理的任务比较耗时，会致使新来的任务都会建立新的线程进行处理，可能会致使建立很是多的线程，最终耗尽系统资源，触发OOM。

PriorityBlockingQueue优先级队列的线程池

package com.itsoku.chat16;

import java.util.concurrent.*;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo3 {

    static class Task implements Runnable, Comparable<Task> {

        private int i;
        private String name;

        public Task(int i, String name) {
            this.i = i;
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
        }

        @Override
        public int compareTo(Task o) {
            return Integer.compare(o.i, this.i);
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(1, 1,
                60L, TimeUnit.SECONDS,
                new PriorityBlockingQueue());
        for (int i = 0; i < 10; i++) {
            String taskName = "任务" + i;
            executor.execute(new Task(i, taskName));
        }
        for (int i = 100; i >= 90; i--) {
            String taskName = "任务" + i;
            executor.execute(new Task(i, taskName));
        }
        executor.shutdown();
    }
}

输出：

pool-1-thread-1处理任务0
pool-1-thread-1处理任务100
pool-1-thread-1处理任务99
pool-1-thread-1处理任务98
pool-1-thread-1处理任务97
pool-1-thread-1处理任务96
pool-1-thread-1处理任务95
pool-1-thread-1处理任务94
pool-1-thread-1处理任务93
pool-1-thread-1处理任务92
pool-1-thread-1处理任务91
pool-1-thread-1处理任务90
pool-1-thread-1处理任务9
pool-1-thread-1处理任务8
pool-1-thread-1处理任务7
pool-1-thread-1处理任务6
pool-1-thread-1处理任务5
pool-1-thread-1处理任务4
pool-1-thread-1处理任务3
pool-1-thread-1处理任务2
pool-1-thread-1处理任务1

输出中，除了第一个任务，其余任务按照优先级高低按顺序处理。缘由在于：建立线程池的时候使用了优先级队列，进入队列中的任务会进行排序，任务的前后顺序由Task中的i变量决定。向PriorityBlockingQueue加入元素的时候，内部会调用代码中Task的compareTo方法决定元素的前后顺序。

自定义建立线程的工厂

给线程池中线程起一个有意义的名字，在系统出现问题的时候，经过线程堆栈信息能够更容易发现系统中问题所在。自定义建立工厂须要实现java.util.concurrent.ThreadFactory接口中的Thread newThread(Runnable r)方法，参数为传入的任务，须要返回一个工做线程。

示例代码：

package com.itsoku.chat16;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo4 {
    static AtomicInteger threadNum = new AtomicInteger(1);

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                60L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10), r -> {
            Thread thread = new Thread(r);
            thread.setName("自定义线程-" + threadNum.getAndIncrement());
            return thread;
        });
        for (int i = 0; i < 5; i++) {
            String taskName = "任务-" + i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "处理" + taskName);
            });
        }
        executor.shutdown();
    }
}

输出：

自定义线程-1处理任务-0
自定义线程-3处理任务-2
自定义线程-2处理任务-1
自定义线程-4处理任务-3
自定义线程-5处理任务-4

代码中在任务中输出了当前线程的名称，能够看到是咱们自定义的名称。

经过jstack查看线程的堆栈信息，也能够看到咱们自定义的名称，咱们能够将代码中executor.shutdown();先给注释掉让程序先不退出，而后经过jstack查看，以下：

4种常见饱和策略

当线程池中队列已满，而且线程池已达到最大线程数，线程池会将任务传递给饱和策略进行处理。这些策略都实现了RejectedExecutionHandler接口。接口中有个方法：

void rejectedExecution(Runnable r, ThreadPoolExecutor executor)

参数说明：
r：须要执行的任务

executor：当前线程池对象

JDK中提供了4种常见的饱和策略:

AbortPolicy：直接抛出异常

CallerRunsPolicy：在当前调用者的线程中运行任务，即随丢来的任务，由他本身去处理

DiscardOldestPolicy：丢弃队列中最老的一个任务，即丢弃队列头部的一个任务，而后执行当前传入的任务

DiscardPolicy：不处理，直接丢弃掉，方法内部为空

自定义饱和策略

须要实现RejectedExecutionHandler接口。任务没法处理的时候，咱们想记录一下日志，咱们须要自定义一个饱和策略，示例代码：

package com.itsoku.chat16;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo5 {
    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "Task{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,
                1,
                60L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                Executors.defaultThreadFactory(),
                (r, executors) -> {
                    //自定义饱和策略
                    //记录一下没法处理的任务
                    System.out.println("没法处理的任务：" + r.toString());
                });
        for (int i = 0; i < 5; i++) {
            executor.execute(new Task("任务-" + i));
        }
        executor.shutdown();
    }
}

输出：

没法处理的任务：Task{name='任务-2'}
没法处理的任务：Task{name='任务-3'}
pool-1-thread-1处理任务-0
没法处理的任务：Task{name='任务-4'}
pool-1-thread-1处理任务-1

输出结果中能够看到有3个任务进入了饱和策略中，记录了任务的日志，对于没法处理多任务，咱们最好可以记录一下，让开发人员可以知道。任务进入了饱和策略，说明线程池的配置可能不是太合理，或者机器的性能有限，须要作一些优化调整。

线程池中的2个关闭方法

线程池提供了2个关闭方法：shutdown和shutdownNow，当调用者两个方法以后，线程池会遍历内部的工做线程，而后调用每一个工做线程的interrrupt方法给线程发送中断信号，内部若是没法响应中断信号的可能永远没法终止，因此若是内部有无线循环的，最好在循环内部检测一下线程的中断信号，合理的退出。调用者两个方法中任意一个，线程池的isShutdown方法就会返回true，当全部的任务线程都关闭以后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。

调用shutdown方法以后，线程池将再也不接口新任务，内部会将全部已提交的任务处理完毕，处理完毕以后，工做线程自动退出。

而调用shutdownNow方法后，线程池会将还未处理的（在队里等待处理的任务）任务移除，将正在处理中的处理完毕以后，工做线程自动退出。

至于调用哪一个方法来关闭线程，应该由提交到线程池的任务特性决定，多数状况下调用shutdown方法来关闭线程池，若是任务不必定要执行完，则能够调用shutdownNow方法。

扩展线程池

虽然jdk提供了ThreadPoolExecutor这个高性能线程池，可是若是咱们本身想在这个线程池上面作一些扩展，好比，监控每一个任务执行的开始时间，结束时间，或者一些其余自定义的功能，咱们应该怎么办？

这个jdk已经帮咱们想到了，ThreadPoolExecutor内部提供了几个方法beforeExecute、afterExecute、terminated，能够由开发人员本身去这些方法。看一下线程池内部的源码：

try {
    beforeExecute(wt, task);//任务执行以前调用的方法
    Throwable thrown = null;
    try {
        task.run();
    } catch (RuntimeException x) {
        thrown = x;
        throw x;
    } catch (Error x) {
        thrown = x;
        throw x;
    } catch (Throwable x) {
        thrown = x;
        throw new Error(x);
    } finally {
        afterExecute(task, thrown);//任务执行完毕以后调用的方法
    }
} finally {
    task = null;
    w.completedTasks++;
    w.unlock();
}

beforeExecute：任务执行以前调用的方法，有2个参数，第1个参数是执行任务的线程，第2个参数是任务

protected void beforeExecute(Thread t, Runnable r) { }

afterExecute：任务执行完成以后调用的方法，2个参数，第1个参数表示任务，第2个参数表示任务执行时的异常信息，若是无异常，第二个参数为null

protected void afterExecute(Runnable r, Throwable t) { }

terminated：线程池最终关闭以后调用的方法。全部的工做线程都退出了，最终线程池会退出，退出时调用该方法

示例代码：

package com.itsoku.chat16;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo6 {
    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "Task{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,
                10,
                60L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                Executors.defaultThreadFactory(),
                (r, executors) -> {
                    //自定义饱和策略
                    //记录一下没法处理的任务
                    System.out.println("没法处理的任务：" + r.toString());
                }) {
            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println(System.currentTimeMillis() + "," + t.getName() + ",开始执行任务:" + r.toString());
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + ",任务:" + r.toString() + "，执行完毕!");
            }

            @Override
            protected void terminated() {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，关闭线程池!");
            }
        };
        for (int i = 0; i < 10; i++) {
            executor.execute(new Task("任务-" + i));
        }
        TimeUnit.SECONDS.sleep(1);
        executor.shutdown();
    }
}

输出：

1564324574847,pool-1-thread-1,开始执行任务:Task{name='任务-0'}
1564324574850,pool-1-thread-3,开始执行任务:Task{name='任务-2'}
pool-1-thread-3处理任务-2
1564324574849,pool-1-thread-2,开始执行任务:Task{name='任务-1'}
pool-1-thread-2处理任务-1
1564324574848,pool-1-thread-5,开始执行任务:Task{name='任务-4'}
pool-1-thread-5处理任务-4
1564324574848,pool-1-thread-4,开始执行任务:Task{name='任务-3'}
pool-1-thread-4处理任务-3
1564324574850,pool-1-thread-7,开始执行任务:Task{name='任务-6'}
pool-1-thread-7处理任务-6
1564324574850,pool-1-thread-6,开始执行任务:Task{name='任务-5'}
1564324574851,pool-1-thread-8,开始执行任务:Task{name='任务-7'}
pool-1-thread-8处理任务-7
pool-1-thread-1处理任务-0
pool-1-thread-6处理任务-5
1564324574851,pool-1-thread-10,开始执行任务:Task{name='任务-9'}
pool-1-thread-10处理任务-9
1564324574852,pool-1-thread-9,开始执行任务:Task{name='任务-8'}
pool-1-thread-9处理任务-8
1564324576851,pool-1-thread-2,任务:Task{name='任务-1'}，执行完毕!
1564324576851,pool-1-thread-3,任务:Task{name='任务-2'}，执行完毕!
1564324576852,pool-1-thread-1,任务:Task{name='任务-0'}，执行完毕!
1564324576852,pool-1-thread-4,任务:Task{name='任务-3'}，执行完毕!
1564324576852,pool-1-thread-8,任务:Task{name='任务-7'}，执行完毕!
1564324576852,pool-1-thread-7,任务:Task{name='任务-6'}，执行完毕!
1564324576852,pool-1-thread-5,任务:Task{name='任务-4'}，执行完毕!
1564324576853,pool-1-thread-6,任务:Task{name='任务-5'}，执行完毕!
1564324576853,pool-1-thread-10,任务:Task{name='任务-9'}，执行完毕!
1564324576853,pool-1-thread-9,任务:Task{name='任务-8'}，执行完毕!
1564324576853,pool-1-thread-9，关闭线程池!

从输出结果中能够看到，每一个须要执行的任务打印了3行日志，执行前由线程池的beforeExecute打印，执行时会调用任务的run方法，任务执行完毕以后，会调用线程池的afterExecute方法，从每一个任务的首尾2条日志中能够看到每一个任务耗时2秒左右。线程池最终关闭以后调用了terminated方法。

合理地配置线程池

要想合理的配置线程池，须要先分析任务的特性，能够冲一下几个角度分析：

任务的性质：CPU密集型任务、IO密集型任务和混合型任务
任务的优先级：高、中、低
任务的执行时间：长、中、短
任务的依赖性：是否依赖其余的系统资源，如数据库链接。

性质不一样任务能够用不一样规模的线程池分开处理。CPU密集型任务应该尽量小的线程，如配置cpu数量+1个线程的线程池。因为IO密集型任务并非一直在执行任务，不能让cpu闲着，则应配置尽量多的线程，如：cup数量*2。混合型的任务，若是能够拆分，将其拆分红一个CPU密集型任务和一个IO密集型任务，只要这2个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。能够经过Runtime.getRuntime().availableProcessors()方法获取cpu数量。优先级不一样任务能够对线程池采用优先级队列来处理，让优先级高的先执行。

使用队列的时候建议使用有界队列，有界队列增长了系统的稳定性，若是采用无解队列，任务太多的时候可能致使系统OOM，直接让系统宕机。

线程池中线程数量的配置

线程池汇总线程大小对系统的性能有必定的影响，咱们的目标是但愿系统可以发挥最好的性能，过多或者太小的线程数量没法有消息的使用机器的性能。咋Java Concurrency inPractice书中给出了估算线程池大小的公式：

Ncpu = CUP的数量
Ucpu = 目标CPU的使用率，0<=Ucpu<=1
W/C = 等待时间与计算时间的比例
为保存处理器达到指望的使用率，最有的线程池的大小等于：
Nthreads = Ncpu × Ucpu × (1+W/C)

一些使用建议

在《阿里巴巴java开发手册》中指出了线程资源必须经过线程池提供，不容许在应用中自行显示的建立线程，这样一方面是线程的建立更加规范，能够合理控制开辟线程的数量；另外一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不容许使用Executors去建立，而要经过ThreadPoolExecutor方式，这一方面是因为jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等建立线程池的方法，但都有其局限性，不够灵活；另外因为前面几种方法内部也是经过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于你们明确线程池的运行规则，建立符合本身的业务场景须要的线程池，避免资源耗尽的风险。

ThreadPoolTaskExecutor 其余知识点汇总(待补充)

线程池中的全部线程超过了空闲时间都会被销毁么？
若是allowCoreThreadTimeOut为true，超过了空闲时间的全部线程都会被回收，不过这个值默认是false，系统会保留核心线程，其余的会被回收
空闲线程是如何被销毁的？
全部运行的工做线程会尝试从队列中获取任务去执行，超过必定时间（keepAliveTime）尚未拿到任务，本身主动退出
核心线程在线程池建立的时候会初始化好么？
默认状况下，核心线程不会进行初始化，在刚开始调用线程池执行任务的时候，传入一个任务会建立一个线程，直到达到核心线程数。不过能够在建立线程池以后，调用其prestartAllCoreThreads提早将核心线程建立好。

java高并发系列

高并发系列连载中，感兴趣的加我微信itsoku，一块儿交流，关注公众号：路人甲Java，天天获取最新连载文章！