什么是线程池
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。目前JDK提供的线程池有两种类型，第一种就是普通的线程池ThreadPoolExecutor，第二种是ForkJoinPool,正式学习线程池之前，先了解一些前置小知识，Task和Future。
Task
- Runnable 不带返回值—void run()
- Callable 伴有返回值—T call()
Future
用于接收任务的返回值，常搭配Callable使用，接收call()方法的返回值
FutureTask
既是一个任务Task，又是一个Future,因为FutureTask他实现了RunnableFuture，而RunnableFuture即实现了Runnable又实现了Future。大家记住这个类，后面还会有WorkStealingPool、ForkJoinPool基本上是会用到FutureTask类的
package com.my.controller.executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
/**
* FutureTask的简单使用
* 本身是个任务，任务执行后的结果又封装到本身
*/
public class TestFuture {
public static void main(String[] args) throws InterruptedException, ExecutionException {
FutureTask<Integer> task = new FutureTask<>(()->{
TimeUnit.MILLISECONDS.sleep(3000);
return 1000;
}); //new Callable () { Integer call();}
new Thread(task).start();
// task.run();
System.out.println("blocking...");
System.out.println(task.get()); //阻塞
System.out.println("main");
}
}CompletableFuture
各种任务的一种管理类，管理多个Future，比如说你可以对任务进行各种各样的组合 ，所有任务完成之后你要得到一个什么样的结果，是整合多个任务的结果还是怎么处理就是程序员自己的事了。还有它可以提供一个链式的处理方式Lambda的一些写法，拿到任务结果之后进行一个怎样的处理。
/**
* 假设你能够提供一个服务
* 这个服务查询各大电商网站同一类产品的价格并汇总展示
* @author Young
*/
package com.my.controller.executor;
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class TestCompletableFuture {
public static void main(String[] args) throws ExecutionException, InterruptedException {
long start, end;
/*start = System.currentTimeMillis();
priceOfTM();
priceOfTB();
priceOfJD();
end = System.currentTimeMillis();
System.out.println("use serial method call! " + (end - start));*/
start = System.currentTimeMillis();
CompletableFuture<Double> futureTM = CompletableFuture.supplyAsync(()->priceOfTM());
CompletableFuture<Double> futureTB = CompletableFuture.supplyAsync(()->priceOfTB());
CompletableFuture<Double> futureJD = CompletableFuture.supplyAsync(()->priceOfJD());
// Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete. If any of the given CompletableFutures complete exceptionally, then the returned CompletableFuture also does so
CompletableFuture.allOf(futureTM, futureTB, futureJD).join();
//例如到天猫商城拿到某件产品的价格后，以lambda的方式进行处理任务执行后返回的结果
/* CompletableFuture.supplyAsync(()->priceOfTM())
.thenApply(String::valueOf)
.thenApply(str-> "price " + str)
.thenAccept(System.out::println);*/
end = System.currentTimeMillis();
System.out.println("use completable future! " + (end - start));
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
private static double priceOfTM() {
delay();
return 1.00;
}
private static double priceOfTB() {
delay();
return 2.00;
}
private static double priceOfJD() {
delay();
return 3.00;
}
/*private static double priceOfAmazon() {
delay();
throw new RuntimeException("product not exist!");
}*/
private static void delay() {
int time = new Random().nextInt(500);
try {
TimeUnit.MILLISECONDS.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("After %s sleep!\n", time);
}
}接下来正式来了解线程池相关的知识：
一、ThreadPoolExecutor
ThreadPoolExecutor他的父类是AbstractExecutorService，而AbstractExecutorService的父类是ExecutorService，再ExecutorService的父类是Executor，所以ThreadPoolExecutor就相当于线程的执行器，就是大家伙儿可以向这个池子里面扔任务，让这个线程池去运行。线程池维护两个集合，第一个是线程的集合，里面是一个一个的线程。第二个是任务的集合，里面是一个一个的任务。
线程池的自定义，包含七个参数
- 第一个参数corePoolSize核心线程数，最开始的时候是有这个线程池里面是有一定的核心线程数的；
- 第二个叫maximumPoolSize最大线程数，线程数不够了，能扩展到最大线程是多少;
- 第三个keepAliveTime生存时间，意思是这个线程有很长时间没干活了请你把它归还给操作系统;
- 第四个TimeUnit.SECONDS生存时间的单位到底是毫秒纳秒还是秒自己去定义；
- 第五个是任务队列，如各种各样的BlockingQueue你都可以往里面扔，我们这用的是ArrayBlockingQueue，可以定义队列的容量；
- 第六个是线程工厂defaultThreadFactory，他返回的是一个new DefaultThreadFactory,它实现ThreadFactory的接口，这个接口只有一个方法叫newThread，所以就是产生线程的，可以通过这种方式产生自定义的线程，默认使用的是defaultThreadFactory，而defaultThreadFactory产生线程的时候有几个特点：new出来的时候指定了group制定了线程名字，然后指定的这个线程绝对不是守护线程，设定好你线程的优先级。自己可以定义产生的到底是什么样的线程，指定线程名叫什么（为什么要指定线程名称，有什么意义，就是可以方便出错时回溯）；
- 第七个叫拒绝策略，指的是线程池忙，而且任务队列满这种情况下我们就要执行各种各样的拒绝策略，jdk默认提供了四种拒绝策略，也是可以自定义的
- Abort：抛异常
- Discard：扔掉，不抛异常
- DiscardOldest：扔掉排队时间最久的（也就是最先被扔进队列的那个任务）
- CallerRunsPolicy调用者处理服务（哪个线程初始化的线程池，这个任务就给谁处理，一般是main线程）
看看以下小程序消化一下，此程序中线程池的拒绝策略是CallerRunsPolicy，其他策略省略演示：
package com.my.controller.executor;
import java.io.IOException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPoolExecutor {
//实现Runnable,定义一个普通任务
static class Task implements Runnable {
private int i;
public Task(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " Task " + i);
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return "Task{" +
"i=" + i +
'}';
}
}
public static void main(String[] args) {
ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4,
60, TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i < 8; i++) {
tpe.execute(new Task(i));
}
System.out.println(tpe.getQueue());
//线程池中一次最多执行8个任务，此时再添加一个任务让他执行，线程池是拒绝的，根据拒绝策略CallerRunsPolicy，交个调用者处理，因为这个任务是添加操作是在main线程中添加的，所以这个任务交给main线程执行
tpe.execute(new Task(100));
System.out.println(tpe.getQueue());
tpe.shutdown();
}
}
线程池工厂Executors创建线程池
JDK给我们提供了一些默认的线程池的实现，Executors可以看作是线程池的工厂。他是用来产生各种各样的线程池的。接下来我们看看默认的常用的线程池有哪些
1、SingleThreadPool
看名字就知道这个线程池里面只有一个线程，这个一个线程的线程池可以保证我们扔进去的任务是顺序执行的，扔一个执行一个，肯定会有人问这样一个问题，为什么会有单线程的线程池？第一个线程池是有任务队列的；生命周期管理线程池是能帮你提供的；
package com.my.controller.executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestSingleThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
for(int i=0; i<5; i++) {
final int j = i;
service.execute(()->{
System.out.println(j + " " + Thread.currentThread().getName());
});
}
}
}
2、CachedPool
我们来看第二种CachedPool，看他的源码实际上是new了一个ThreadPoolExecutor，他没有核心线程，最大线程可以有好多好多线程，然后60秒钟没有人理他，就回收了，他的任务队列用的是SynchronousQueue，没有指定他的线程工厂他是用的默认线程工厂的，也没有指定拒绝策略，他是默认拒绝策略的。具体可去看源码了解，不多说了。
package com.my.controller.executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class TestCachedPool {
public static void main(String[] args) throws InterruptedException {
ExecutorService service = Executors.newCachedThreadPool();
System.out.println("1---"+service);
for (int i = 0; i < 2; i++) {
service.execute(() -> {
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
});
}
System.out.println("2---"+service);
// 假如主线程睡80s,线程池中的空闲线程将会被回收掉
TimeUnit.SECONDS.sleep(5);
System.out.println("3---"+service);
}
}
3、FixedThreadPool
你看他的名称，fixed是固定的含义，就是固定的一个线程数，FixedThreadPool指定一个参数，到底有多少个线程，你看他的核心线程和最大线程都是一样，也就说都是核心线程，核心线程是不能被系统回收的，所以keepAliveTime没有意义，这里用的队列是LinkedBlockingQueue。
我们来看一下这个FixedThreadPool的小例子，用一个固定的线程池有一个好处是什么呢，就是你可以进行并行的计算，那么说到这儿并行和并发有什么区别concurrent vs parallel:并发是指任务提交，并行指任务执行；并行是并发的子集。并行是多个cpu可以同时进行处理，并发是多个任务同时过来。要理解这个概念。FixedThreadPool是确实可以让你的任务来并行处理的，那么并行处理的时候就可以真真正正的提高效率。看这个方法isPrime判断一个数是不是质数，然后写了另外一个getPrime方法，指定一个起始的位置，一个结束的位置将中间的质数拿出来一部分，主要是为了把任务给切分开。计算从1一直到200000这么一些数里面有多少个数是质数getPrime，计算了一下时间，只有我们一个main线程来运行，不过我们既然学了多线程就完全可以这个任务切分成好多好多子任务让多线程来共同运行，我有多少cpu，我的机器是6核的，这个取决你的机器数，在启动了一个固定大小的线程池，然后在分别来计算，分别把不同的阶段交给不同的任务，扔进去submit他是异步的，拿到get的时候才知道里面到底有多少个，全部get完了之后相当于所有的线程都知道结果了，最后我们计算一下时间，用这两种计算方式就能比较出来到底是并行的方式快还是串行的方式快
package com.my.controller.executor;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class TestFixedThreadPool {
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
getPrime(1, 200000);
long end = System.currentTimeMillis();
System.out.println(end - start);
final int cpuCoreNum = 6;
ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);
MyTask t1 = new MyTask(1, 80000); //1-5 5-10 10-15 15-20
MyTask t2 = new MyTask(80001, 130000);
MyTask t3 = new MyTask(130001, 170000);
MyTask t4 = new MyTask(170001, 200000);
Future<List<Integer>> f1 = service.submit(t1);
Future<List<Integer>> f2 = service.submit(t2);
Future<List<Integer>> f3 = service.submit(t3);
Future<List<Integer>> f4 = service.submit(t4);
start = System.currentTimeMillis();
List<Integer> integers = f1.get();
// System.out.println("f1===="+integers);
f2.get();
f3.get();
f4.get();
end = System.currentTimeMillis();
System.out.println(end - start);
service.shutdown();
}
static class MyTask implements Callable<List<Integer>> {
int startPos, endPos;
MyTask(int s, int e) {
this.startPos = s;
this.endPos = e;
}
@Override
public List<Integer> call() throws Exception {
List<Integer> r = getPrime(startPos, endPos);
return r;
}
}
static boolean isPrime(int num) {
for(int i=2; i<=num/2; i++) {
if(num % i == 0) return false;
}
return true;
}
static List<Integer> getPrime(int start, int end) {
List<Integer> results = new ArrayList<>();
for(int i=start; i<=end; i++) {
if(isPrime(i)) results.add(i);
}
// System.out.println(results);
return results;
}
}4、ScheduledPool
ScheduledPool定时任务线程池，就是我们原来学过一个定时器任务，隔一段时间之后这个任务会执行。这个就是我们专门用来执行定时任务的一个线程池。看源码，我们newScheduledThreadPool的时候他返回的是ScheduledThreadPoolExecutor，然后在ScheduledThreadPoolExecutor里面他调用了super，他的super又是ThreadPoolExecutor，它本质上还是ThreadPoolExecutor，所以并不是别的，参数还是ThreadPool的七个参数。这是专门给定时任务用的这样的一个线程池，了解就可以了。
看程序，newScheduledThreadPool核心线程是4，其实他这里面有一些好用的方法比如是scheduleAtFixedRate间隔多长时间在一个固定的频率上来执行一次这个任务，可以通过这样的方式灵活的对于时间上的一个控制，第一个参数（Delay）第一个任务执行之前需要往后面推多长时间；第二个（period）间隔多长时间；第三个参数是时间单位;
package com.my.controller.executor;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class TestScheduledThreadPool {
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
service.scheduleAtFixedRate(()->{
try {
TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
System.out.println("task running...");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}, 0, 500, TimeUnit.MILLISECONDS);
try {
TimeUnit.SECONDS.sleep(6);
} catch (InterruptedException e) {
e.printStackTrace();
}
service.shutdown();
}
}5、WorkStealingPool
这个WorkStealingPool是另外一种线程池，核心非常简单，原来我们讲的线程池，一个线程的集合然后去另外一个任务的队列里头取任务，取了执行。WorkStealing指的是和原来线程池的区别每一个线程都有自己单独队列，所以任务不断往里扔的时候它会在每一个线程的队列上不断的累积，让某一个线程执行完自己的任务之后就会去另外一个线程上面的任务队列里偷任务执行，你给我一个拿来我用，所以这个叫WorkStealing。好处就是任务量轻的线程可以替任务量重的线程分担压力。
package com.my.controller.executor;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class TestWorkStealingPool {
public static void main(String[] args) throws IOException {
ExecutorService service = Executors.newWorkStealingPool();
// cpu核数个线程
int i1 = Runtime.getRuntime().availableProcessors();
System.out.println(i1);
// workStealingPool 会自动启动cpu核数个(本机12个)线程去执行任务
// 先执行一个
service.execute(new R(1000));
// 再执行il（12）个任务，势必有一个任务等待，直到最后一个等待的任务被第一个先执行完的任务偷偷执行
for (int i = 0; i < i1 ; i++) {
service.execute(new R(2000));
}
//由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出
System.in.read();
}
static class R implements Runnable {
int time;
R(int t) {
this.time = t;
}
@Override
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(time + " " + Thread.currentThread().getName());
}
}
}
二、ForkJoinPool
ForkJoinPool是这样一种线程池，它适合把大任务切分成一个一个的小任务去运行，小任务还是觉得比较大，再切，不一定是两个，也可以切成三个四个。切完这个任务执行完了要进行一个汇总，当然也有一些打印输出的任务不需要返回值的，只不过我们很多情况是需要进行一个结果的汇总，子任务汇总到父任务，父任务最终汇总到根任务，最后我们就得到了所有的结果，这个过程叫join，因此这个线程池就叫做ForkJoinPool。
那我们怎么样定义这个任务呢？我们原来定义任务的时候是从Runnable来继承，在这里我们一般实现ForkJoinPool的时候需要定义成为特定的他的类型 ，这个类型呢是必须得能进行分叉的任务，所以他定义成是一种特殊类型的任务，这个叫ForkJoinTask，但是实际当中这个ForkJoinTask比较原始，我们可以用这个RecursiveAction，这里面有两种，第一种叫RecursiveAction递归，为什么叫递归，是因为我们大任务可以切成小任务，小任务还可以切成小任务，一直可以切到满足我的条件为止，这其中隐含了一个递归的过程，因此叫RecursiveAction，是不带返回值的任务。
来看不带返回值的任务这个小程序，我new了一个数组，这个数组长度为100万，这个数组里面装了很多数，这些数都是通过Random来new出来的，下面我要对一堆数进行总和的计算，如果我用单线程来计算可以这样来计算：Arrays.stream(nums).sum() 搞定，这是单线程，这个时间会比较长，我们可以进行多线程的计算，就像之前我们写过的FixedThreadPool，现在我们可以用ForkJoinPool来做计算，在计算的时候我要去最小的任务片这个数是不超过5万个数，你就不用在分了。 RecursiveAction是我们的任务，是用来做总和的，由于这里面是把数组进行了分片，所以定义了一个起始的位置和一个结束的位置，然后来进行compute计算。如果说我们这个数组里面的分片数量要比那个我们定义最小数量少了就是5万个数少了就直接进行计算就行，否则的话中间在砍掉一半，砍完了之后把当前任务在分成两个子任务，然后在让两个子任务进行分叉进行fork。这些任务有自己的一些特点，就是背后的后台线程 ，所以我需要通过一个阻塞操作让当前的main函数不退出，不然的话他一退出所有线程全退出了，ok，这个是叫做没有返回值的任务。
package com.my.controller.executor;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
public class TestForkJoinPool {
static int[] nums = new int[1000000];
static final int MAX_NUM = 50000;
static Random r = new Random();
static {
for(int i=0; i<nums.length; i++) {
nums[i] = r.nextInt(100);
}
System.out.println("---" + Arrays.stream(nums).sum()); //stream api
}
// 不带返回值的递归任务，继承的时候不带泛型，即不带返回值
static class AddTask extends RecursiveAction {
int start, end;
AddTask(int s, int e) {
start = s;
end = e;
}
@Override
protected void compute() {
if(end-start <= MAX_NUM) {
long sum = 0L;
for(int i=start; i<end; i++) sum += nums[i];
System.out.println("from:" + start + " to:" + end + " = " + sum);
} else {
int middle = start + (end-start)/2;
AddTask subTask1 = new AddTask(start, middle);
AddTask subTask2 = new AddTask(middle, end);
subTask1.fork();
subTask2.fork();
}
}
}
// 带返回值的递归任务，继承的时候规定泛型，即返回值的类型
static class AddTaskRet extends RecursiveTask<Long> {
private static final long serialVersionUID = 1L;
int start, end;
AddTaskRet(int s, int e) {
start = s;
end = e;
}
@Override
protected Long compute() {
if(end-start <= MAX_NUM) {
long sum = 0L;
for(int i=start; i<end; i++) sum += nums[i];
return sum;
}
int middle = start + (end-start)/2;
AddTaskRet subTask1 = new AddTaskRet(start, middle);
AddTaskRet subTask2 = new AddTaskRet(middle, end);
subTask1.fork();
subTask2.fork();
return subTask1.join() + subTask2.join();
}
}
public static void main(String[] args) throws IOException {
/*ForkJoinPool fjp = new ForkJoinPool();
AddTask task = new AddTask(0, nums.length);
fjp.execute(task);*/
TestForkJoinPool temp = new TestForkJoinPool();
ForkJoinPool fjp = new ForkJoinPool();
AddTaskRet task = new AddTaskRet(0, nums.length);
// AddTask nonResTask = new AddTask(0,nums.length);
fjp.execute(task);
// fjp.execute(nonResTask);
long result = task.join();
System.out.println(result);
//System.in.read();
}
}来看最后一个小程序，这个小程序的底层也是用的ForkJoinPool实现的，也是ForkJoinPool的算法来实现的，就是流式API，本身不难，就是你把一个集合里的内容想象成一个河流一样，一个一个往外流，流到我们这的时候处理一下。流式处理的方式就是大家调各种的对集合里面迭代的需要处理每个元素的时候，这种时候处理起来更方便一些。
举例，我们new了一个ArrayList往里面装了10000个数，然后我让这个数进行计算，判断他是不是质数nums.forEach这个是lambda表达式同时也是一个流式处理，forEach就是拿出一个来计算看他是不是一个质数，然后计算一个时间，下面我用的是另外一种，上面是forEach在当前线程里面拿出每一个来，下面用的是parallelStream并行流，并行流的意思是它会把里面并行的来进行处理把这个任务切分成一个个子任务，这个时候里面也是用的ForkJoinPool，两个对比就会有时间差的一个差距，所以在互相之间这个线程不需要同步的时候，你可以用这种并行流来进行处理效率会更高一些，他底层的实现也是ForkJoinPool。
package com.my.controller.executor;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class TestParallelStreamAPI {
public static void main(String[] args) {
List<Integer> nums = new ArrayList<>();
Random r = new Random();
for(int i=0; i<10000; i++) nums.add(1000000 + r.nextInt(1000000));
//System.out.println(nums);
long start = System.currentTimeMillis();
nums.forEach(v->isPrime(v));
long end = System.currentTimeMillis();
System.out.println(end - start);
//使用parallel stream api
start = System.currentTimeMillis();
nums.parallelStream().forEach(TestParallelStreamAPI::isPrime);
end = System.currentTimeMillis();
System.out.println(end - start);
}
static boolean isPrime(int num) {
for(int i=2; i<=num/2; i++) {
if(num % i == 0) return false;
}
return true;
}
}线程池，我们回顾一下有两种
- ThreadPoolExecutor
- ForkJoinPool
他们两个的区别，前面这个ThreadPoolExecutor多个线程共享同一个任务队列；下面这个ForkJoinPool每个线程有自己的任务队列。
