Java 线程池的简单使用及介绍

一、概述：

为什么要使用线程池？在实际开发过程中，如果不使用线程池，有可能会不加节制的去创建新的线程导致服务器cpu资源占满，无法相应其他请求。所以使用线程池就是为了控制开启多线程情况下，对其有开销控制，不会导致上面问题发生。在创建线程池时，我们建议使用ThreadPoolExecutor 而代替Executors 去创建是因为Executors内部也是使用的ThreadPoolExecutor进行的创建，并且有一定的局限性。所以为了创建符合自己的业务场景需要我们使用ThreadPoolExecutor进行创建线程池。

ThreadPoolExecutor的构造函数：

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;}

corePoolSize:线程池中的可并行运行线程数量，当前启用线程数等于该值后待开启线程将会将待开启的线程放入到等待队列中去；

maximumPoolSize: 直接提交队列时最多线程数量，

keepAliveTime:当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；

unit:keepAliveTime的单位

workQueue:任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；

threadFactory:线程工厂，用于创建线程，一般用默认即可；

handler:拒绝策略；当任务太多来不及处理时，如何拒绝任务；

二、四种不同任务队列

线程池中的不同任务队列有着不同的线程任务处理规则。

1 , 直接提交队列（SynchronousQueue实现）

规则最简单的任务队列，主要使用SynchronousQueue进行存放线程实现类。其中第一个corePoolSize值设置无效，默认设置为0，主要设置其maximumPoolSize。当我们在同时开启多个线程时，在maximumPoolSize之内的都可以被正常开启，当超过maximumPoolSize数量时则执行拒绝策略。

package com.xiaohui.thread;import java.util.concurrent.*;/*** SynchronousQueue 直接提交队列* corePoolSize 无用，超过maximumPoolSize 则执行拒绝策略*/
public class SynchronousQueueThreadPool {private static ExecutorService pool;public static void main( String[] args ){pool = new ThreadPoolExecutor(0, 4, 1000, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());for(int i=0;i<5;i++) {pool.execute(new ThreadTask());}}
}

package com.xiaohui.thread;import java.util.Date;public class ThreadTask implements Runnable{public ThreadTask() {}public void run() {System.out.println(Thread.currentThread().getName()+"----start sleep"+new Date().toLocaleString());long l = System.currentTimeMillis();try{Thread.sleep(2000);System.out.println(Thread.currentThread().getName()+"----sleep   end"+new Date().toLocaleString()+",运行时间:"+(System.currentTimeMillis()-l));}catch (Exception e){}}
}

打印结果：48秒时同时开启四条线程，开启第五条时，直接执行拒绝测试抛出RejectedExecutionException

D:\Java\jdk1.8.0_131\bin\java.exe "-javaagent:D:\Java\JetBrains\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=55468:D:\Java\JetBrains\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath D:\Java\jdk1.8.0_131\jre\lib\charsets.jar;D:\Java\jdk1.8.0_131\jre\lib\deploy.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;D:\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;D:\Java\jdk1.8.0_131\jre\lib\javaws.jar;D:\Java\jdk1.8.0_131\jre\lib\jce.jar;D:\Java\jdk1.8.0_131\jre\lib\jfr.jar;D:\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;D:\Java\jdk1.8.0_131\jre\lib\jsse.jar;D:\Java\jdk1.8.0_131\jre\lib\management-agent.jar;D:\Java\jdk1.8.0_131\jre\lib\plugin.jar;D:\Java\jdk1.8.0_131\jre\lib\resources.jar;D:\Java\jdk1.8.0_131\jre\lib\rt.jar;F:\stuproject\ThreadPool\target\classes com.xiaohui.thread.SynchronousQueueThreadPool
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.xiaohui.thread.ThreadTask@330bedb4 rejected from java.util.concurrent.ThreadPoolExecutor@2503dbd3[Running, pool size = 4, active threads = 4, queued tasks = 0, completed tasks = 0]at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)at com.xiaohui.thread.SynchronousQueueThreadPool.main(SynchronousQueueThreadPool.java:15)
pool-1-thread-1----start sleep2020-7-22 17:58:48
pool-1-thread-2----start sleep2020-7-22 17:58:48
pool-1-thread-3----start sleep2020-7-22 17:58:48
pool-1-thread-4----start sleep2020-7-22 17:58:48
pool-1-thread-1----sleep   end2020-7-22 17:58:50,运行时间:2000
pool-1-thread-3----sleep   end2020-7-22 17:58:50,运行时间:2001
pool-1-thread-2----sleep   end2020-7-22 17:58:50,运行时间:2000
pool-1-thread-4----sleep   end2020-7-22 17:58:50,运行时间:2001Process finished with exit code 1

2 , 有界任务队列（ArrayBlockingQueue实现）

在有界任务队列中创建线程时，当创建数量达到corePoolSize时，其他需要创建的队列会放到等待队列中，当等待队列中达到初始化的大小后，继续创建，当超过maximumPoolSize 时会执行拒绝策略（当同时启用的任务较少时，超过max数量也正常执行，不是按上述进行。当启用数量较大时则按上面进行执行）

package com.xiaohui.thread;import java.util.concurrent.*;public class ArrayBlockingQueueThreadPool {private static ExecutorService pool;public static void main( String[] args ){pool = new ThreadPoolExecutor(4, 8, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(6), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());for(int i=0;i<10;i++) {pool.execute(new ThreadTask());}}
}

ThreadTask类同1中的代码。打印如下（当同时开启数量为15时会抛出拒绝策略错误）：

pool-1-thread-4----start sleep2020-7-22 18:32:03
pool-1-thread-2----start sleep2020-7-22 18:32:03
pool-1-thread-3----start sleep2020-7-22 18:32:03
pool-1-thread-1----start sleep2020-7-22 18:32:03
pool-1-thread-4----sleep   end2020-7-22 18:32:05,运行时间:2000
pool-1-thread-4----start sleep2020-7-22 18:32:05
pool-1-thread-1----sleep   end2020-7-22 18:32:05,运行时间:2000
pool-1-thread-1----start sleep2020-7-22 18:32:05
pool-1-thread-2----sleep   end2020-7-22 18:32:05,运行时间:2023
pool-1-thread-2----start sleep2020-7-22 18:32:05
pool-1-thread-3----sleep   end2020-7-22 18:32:05,运行时间:2023
pool-1-thread-3----start sleep2020-7-22 18:32:05
pool-1-thread-4----sleep   end2020-7-22 18:32:07,运行时间:2000
pool-1-thread-4----start sleep2020-7-22 18:32:07
pool-1-thread-1----sleep   end2020-7-22 18:32:07,运行时间:2002
pool-1-thread-1----start sleep2020-7-22 18:32:07
pool-1-thread-2----sleep   end2020-7-22 18:32:07,运行时间:2000
pool-1-thread-3----sleep   end2020-7-22 18:32:07,运行时间:2002
pool-1-thread-4----sleep   end2020-7-22 18:32:09,运行时间:2000
pool-1-thread-1----sleep   end2020-7-22 18:32:09,运行时间:2000

3，无界任务队列（LinkedBlockingQueue实现）

在无界任务队列中最大线程数量参数无效，同时可运行线程数量为corePoolSize,当开启的线程数量超过corePoolSize时，待开启的线程会放入链表队列中。没有最大线程数量限制。当线程池中的线程执行完成之后，将从链表等待队列中获取进行执行。

package com.xiaohui.thread;import java.util.concurrent.*;public class LinkedBlockingQueueThreadPool {private static ExecutorService pool;public static void main( String[] args ){pool = new ThreadPoolExecutor(3,6, //无效参数1000,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());for(int i=0;i<10;i++) {pool.execute(new ThreadTask());}}
}

ThreadTask类同1中的代码。打印如下（同时开启三个，三个线程同时结束后，在开启三个进行执行...）：

pool-1-thread-1----start sleep2020-7-22 18:34:51
pool-1-thread-3----start sleep2020-7-22 18:34:51
pool-1-thread-2----start sleep2020-7-22 18:34:51
pool-1-thread-1----sleep   end2020-7-22 18:34:53,运行时间:2000
pool-1-thread-1----start sleep2020-7-22 18:34:53
pool-1-thread-3----sleep   end2020-7-22 18:34:53,运行时间:2000
pool-1-thread-2----sleep   end2020-7-22 18:34:53,运行时间:2000
pool-1-thread-3----start sleep2020-7-22 18:34:53
pool-1-thread-2----start sleep2020-7-22 18:34:53
pool-1-thread-2----sleep   end2020-7-22 18:34:55,运行时间:2013
pool-1-thread-2----start sleep2020-7-22 18:34:55
pool-1-thread-3----sleep   end2020-7-22 18:34:55,运行时间:2022
pool-1-thread-3----start sleep2020-7-22 18:34:55
pool-1-thread-1----sleep   end2020-7-22 18:34:55,运行时间:2024
pool-1-thread-1----start sleep2020-7-22 18:34:55
pool-1-thread-2----sleep   end2020-7-22 18:34:57,运行时间:2001
pool-1-thread-2----start sleep2020-7-22 18:34:57
pool-1-thread-3----sleep   end2020-7-22 18:34:57,运行时间:2000
pool-1-thread-1----sleep   end2020-7-22 18:34:57,运行时间:2001
pool-1-thread-2----sleep   end2020-7-22 18:34:59,运行时间:2000

4，优先任务队列（PriorityBlockingQueue实现）

优先任务队列中，线程类需要实现Comparable接口。在首次启动线程后，同时开启了corePoolSize个线程之后，其他需要待执行的线程队列将被放到PriorityBlockingQueue队列中，并进行了比较排序，首次启用的线程执行完成之后，将会从待执行队列中获取排序后的corePoolSize个线程，并进行执行。

package com.xiaohui.thread;import java.util.Date;public class ThreadTask implements Runnable,Comparable<ThreadTask>{private int weight = 0;public ThreadTask() {}public ThreadTask(int weight) {this.weight = weight;}public void run() {System.out.println(weight+"--"+Thread.currentThread().getName()+"----start sleep"+new Date().toLocaleString());long l = System.currentTimeMillis();try{Thread.sleep(2000);
//            System.out.println(weight+"--"+Thread.currentThread().getName()+"----sleep   end"+new Date().toLocaleString()+",运行时间:"+(System.currentTimeMillis()-l));}catch (Exception e){}}public int compareTo(ThreadTask o) {return this.weight > o.weight  ?-1:1;}
}

package com.xiaohui.thread;import java.util.concurrent.*;public class PriorityBlockingQueueThreadPool {private static ExecutorService pool;public static void main( String[] args ){pool = new ThreadPoolExecutor(4,10, //无效参数1000,TimeUnit.MILLISECONDS,new PriorityBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());for(int i=0;i<10;i++) {pool.execute(new ThreadTask(i));}}
}

运行打印结果如下（首次四个线程2、1、3、0为无序的执行，当前4个执行完成之后，进行按排序后的线程获取执行）：

2--pool-1-thread-3----start sleep2020-7-22 18:44:33
1--pool-1-thread-2----start sleep2020-7-22 18:44:33
3--pool-1-thread-4----start sleep2020-7-22 18:44:33
0--pool-1-thread-1----start sleep2020-7-22 18:44:33
9--pool-1-thread-3----start sleep2020-7-22 18:44:35
8--pool-1-thread-2----start sleep2020-7-22 18:44:35
7--pool-1-thread-4----start sleep2020-7-22 18:44:35
6--pool-1-thread-1----start sleep2020-7-22 18:44:35
5--pool-1-thread-3----start sleep2020-7-22 18:44:37
4--pool-1-thread-2----start sleep2020-7-22 18:44:37