Java线程池

概念

为了更好的控制多线程，JDK提供了一套线程框架Executor,帮助开发人员有效地进行线程控制。它们都java.util.concurrent包中，是JDK并发包的核心。其中有一个比较重要的类：Executors,他扮演着线程工厂的角色，我们通过Executors可以创建特定功能的线程池。

Executors创建线程池方法：

• newFixedThreadPool(int nThreads)，该方法会返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中等待有空闲的线程去执行
• newSingleThreadExecutor(),创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务队列中。
• newCachedThreadPool()，返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若有空闲的线程则执行任务，若无任务则不创建线程，并且每一个空闲线程会在60秒后自动回收。
• newScheduledThreadPool(int nThreads)，该方法返回一个SchededExecutorService对象，该线程池可以指定线程的数量。

源码

我们来分别看一下创建四个线程池方法的源码实现。我们会很惊奇的发现它们的相似之处

1.Executors.newFixedThreadPool(10)

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

2.Executors.newSingleThreadExecutor()

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

3.Executors.newCachedThreadPool()

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

4.Executors.newScheduledThreadPool(10)，在结构上可能有些不同，究其根本我们可以发现，它和前三种也是相似的。

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {        return new ScheduledThreadPoolExecutor(corePoolSize);    }

我们继续深入ScheduledThreadPoolExecutor(corePoolSize)

    public ScheduledThreadPoolExecutor(int corePoolSize) {        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,              new DelayedWorkQueue());    }

这里调用了父类的构函，我们来看它的父类是谁。

public class ScheduledThreadPoolExecutor        extends ThreadPoolExecutor        implements ScheduledExecutorService 

会发现竟然也是ThreadPoolExecutor。

看了这四种创建线程池的源码，我们发现底层都是创建了一个ThreadPoolExecutor，每一种创建的方式，只是修改了参数。

我们来了解各个参数的含义。

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

• corePoolSize，表示核心线程数，后面会做详细介绍
• maximumPoolSize，表示最大线程数
• keepAliveTime，表示线程空闲多长时间后被回收
• unit，表示时间的单位。keepAliveTime和unit必须配合起来使用
• workQueue，指定一个队列来存储线程处理不及的任务

事例

1.newScheduledThreadPool实例演示

public class Demo2 {        public static void main(String[] args) {            Temp command =new Temp();            ScheduledExecutorService                      service=Executors.newScheduledThreadPool(1);ScheduledFuture<?> serviceTask=service.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);        }}class Temp extends Thread{    @Override    public void run() {        System.out.println("run...");    }}

运行结果：初始化5秒后，第一个run…在控制台打印出来，以后每隔一秒打印一个。

//关键是这条语句/* command，表示要执行的线程 5，表示初始化的时间 1，表示初始化后每次执行的时间间隔 TimeUnit.SECONDS，表示时间的单位是秒*/ScheduledFuture<?> serviceTask=service.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);

自定义线程

若Executors工厂类无法满足我们的需求，可以自己去创建自定义的线程池，在上文我们可以看到JDK中提供的4中线程池内部实现都用了ThreadPoolExecutor这个类，这个类可以自定义线程。构造方法如下：

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

我们再来介绍一下参数含义：
- corePoolSize，表示核心线程数，后面会做详细介绍
- maximumPoolSize，表示最大线程数
- keepAliveTime，表示线程空闲多长时间后被回收
- unit，表示时间的单位。keepAliveTime和unit必须配合起来使用
- workQueue，指定一个队列来存储线程处理不及的任务
- threadFactory，是指线程工厂
- handler，表示拒绝策略的机制，后面事例会详细演示

详细使用

这个构造方法对于队列是什么类型的比较关键。

• 若队列为有界队列：若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新线程，若线程数大于maximumPoolSize，则执行拒绝策略，或其他自定义方式
• 若队列为无界队列：例如LinkedBlockingQueue，与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败。当有新任务到来，系统的线程数小于corePoolSize，则创建新线程执行任务。当到达corePoolSize后，就不会创建线程。若后续还有任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到内存资源耗尽。

JDK的拒绝策略：

• AbortPolicy:直接抛出异常，组织系统正常工作，但线程池中的线程不能被shutdown()
• CallerRunsPolicy:只要线程池未关闭，该策略直接在调用者线程中运行当前被丢弃的任务
• DiscardOldestPolicy:丢弃最老的一个请求，尝试再次提交当前任务。
• DiscardPolicy:丢弃无法处理的任务，不给予任何处理
• 如果需要自定义拒绝策略可以实现RejectedExecutionHandler接口

实例

首先定义一个任务类

public class MyTask implements Runnable {    private int taskId;    private String taskName;    public MyTask(int taskId, String taskName){        this.taskId = taskId;        this.taskName = taskName;    }    public int getTaskId() {        return taskId;    }    public void setTaskId(int taskId) {        this.taskId = taskId;    }    public String getTaskName() {        return taskName;    }    public void setTaskName(String taskName) {        this.taskName = taskName;    }    @Override    public void run() {        try {            System.out.println("run taskId =" + this.taskId);            Thread.sleep(5*1000);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }    }    public String toString(){        return Integer.toString(this.taskId);    }}

然后是主类，也就是执行类

public class UseThreadPoolExecutor {/**     * 规则1.在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，     * 规则2.若大于corePoolSize，则会将任务加入队列，     * 规则3.若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，     * 规则4.若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。     *  */         //创建corePoolSize为1，maximumPoolSize为2的有界队列线程池        public static void main(String[] args) {                ThreadPoolExecutor pool=new ThreadPoolExecutor(                        1,                        2,                        60,                        TimeUnit.SECONDS,                        new ArrayBlockingQueue<Runnable>(3)                );                //创建一个任务                MyTask mt1=new MyTask(1, "MyTask1");                //执行任务                pool.execute(mt1);                //暂停线程                pool.shutdown();        }}

运行结果是：

打印run taskId =1后，5秒后线程结束。 符合规则1.

再看有四个任务

public class UseThreadPoolExecutor {        public static void main(String[] args) {                ThreadPoolExecutor pool=new ThreadPoolExecutor(                        1,                        2,                        60,                        TimeUnit.SECONDS,                        new ArrayBlockingQueue<Runnable>(3)                );                MyTask mt1=new MyTask(1, "MyTask1");                MyTask mt2=new MyTask(2, "MyTask2");                MyTask mt3=new MyTask(3, "MyTask3");                MyTask mt4=new MyTask(4, "MyTask4");                pool.execute(mt1);                pool.execute(mt2);                pool.execute(mt3);                pool.execute(mt4);                pool.shutdown();        }}

执行结果：打印run taskId =1后，5秒后打印run taskId =2 再过5秒打印run taskId =3，再过5秒打印run taskId =4，再过5秒线程结束，符合规则2. 任务2，任务3，任务4都先存放在有界队列中，此时线程池中只有一条线程，执行完任务1后，在按照队列先进先出的原则分别执行，任务2，任务3，任务4.

再看有5个任务的情况

public class UseThreadPoolExecutor {        public static void main(String[] args) {                ThreadPoolExecutor pool=new ThreadPoolExecutor(                        1,                        2,                        60,                        TimeUnit.SECONDS,                        new ArrayBlockingQueue<Runnable>(3)                );                MyTask mt1=new MyTask(1, "MyTask1");                MyTask mt2=new MyTask(2, "MyTask2");                MyTask mt3=new MyTask(3, "MyTask3");                MyTask mt4=new MyTask(4, "MyTask4");                MyTask mt5=new MyTask(5, "MyTask5");                pool.execute(mt1);                pool.execute(mt2);                pool.execute(mt3);                pool.execute(mt4);                pool.execute(mt5);                pool.shutdown();        }}

运行结果，任务1和任务5一起打印，5秒后任务2和任务3一起打印，再过5秒打印任务4，再过5秒线程结束。符合规则3.因为新加任务5的时候发现有界队列已经满了，并且线程池中只有一条线程小于maximumPoolSize的2.所以又创建了一条线程直接运行任务5.等到任务1和任务5运行完，这两条线程又分别运行任务2和任务3。最后运行任务4.

最后看一下6个任务的情况

public class UseThreadPoolExecutor {        public static void main(String[] args) {                ThreadPoolExecutor pool=new ThreadPoolExecutor(                        1,                        2,                        60,                        TimeUnit.SECONDS,                        new ArrayBlockingQueue<Runnable>(3)                );                MyTask mt1=new MyTask(1, "MyTask1");                MyTask mt2=new MyTask(2, "MyTask2");                MyTask mt3=new MyTask(3, "MyTask3");                MyTask mt4=new MyTask(4, "MyTask4");                MyTask mt5=new MyTask(5, "MyTask5");                MyTask mt6=new MyTask(6, "MyTask6");                pool.execute(mt1);                pool.execute(mt2);                pool.execute(mt3);                pool.execute(mt4);                pool.execute(mt5);                pool.execute(mt6);                pool.shutdown();        }}

结果，打印任务1,5并且任务6抛出异常在同一时间进行。过5秒后打印任务2,3，在过5秒打印任务4，最后线程一直在等待，没有结束。符合规则4.

我们可以看源码得知，没有指定拒绝策略的情况下，默认的拒绝策略就是AbortPolicy：直接抛出异常，组织系统正常工作。

  private static final RejectedExecutionHandler defaultHandler =        new AbortPolicy();

我们还可以自定义拒绝策略

public class MyRejected implements RejectedExecutionHandler{    @Override    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {        System.out.println("自定义处理.....");        System.out.println("当前被拒绝任务为："+r.toString());    }}

修改UseThreadPoolExecutor 类

public class UseThreadPoolExecutor {        public static void main(String[] args) {                ThreadPoolExecutor pool=new ThreadPoolExecutor(                        1,                        2,                        60,                        TimeUnit.SECONDS,                        new ArrayBlockingQueue<Runnable>(3)，                        new                 );                MyTask mt1=new MyTask(1, "MyTask1");                MyTask mt2=new MyTask(2, "MyTask2");                MyTask mt3=new MyTask(3, "MyTask3");                MyTask mt4=new MyTask(4, "MyTask4");                MyTask mt5=new MyTask(5, "MyTask5");                MyTask mt6=new MyTask(6, "MyTask6");                pool.execute(mt1);                pool.execute(mt2);                pool.execute(mt3);                pool.execute(mt4);                pool.execute(mt5);                pool.execute(mt6);                pool.shutdown();        }}

运行结果：自定义处理….. run taskId =5 run taskId =1 当前被拒绝任务为：6同时被打印，5秒后打印run taskId =2 run taskId =3 再过5秒打印run taskId =4 最后再过5秒线程结束。

最后我们补充一个知识点：

排队三种策略：

• 直接提交。如SynchronousQueue，它将任务直接提交给线程而不保持它们。也就是我只是其中间桥梁作用，一个任务过来，我只需要把这个任务直接交给线程，而不保存，适合任务量较少的场景。

• 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize的值也就无效了。）

• 有界队列。如 ArrayBlockingQueue，直接指定了队列可存放的长度，对比无界队列可以有效的方式内存资源耗尽，在队列已满后继续添加任务，我们可以用记录日志的方式来下一次解决。