JUC并发编程(八)-- 线程池
池化技术
我们知道,程序的运行,本质是占用系统的资源,那为了优化资源的时候,就出现了池化技术!
常见的有:线程池、内存池、对象池 等待…
一句话总结池化技术:事先准备好一些资源,有人需要用,就来找我拿,用完还要还给我。
线程池的优点
- 降低资源的消耗;
- 提高响应的速度;
- 方便管理。
线程复用、可以控制连接数、最大并发数等等,管理线程
线程池的用法
三大方法,七大参数、四种拒绝策略
一、三大方法
虽说阿里开发手册上,强制不允许使用Executors创建,但目前我们处于demo阶段,所以这里的三大方法我们还是用Executros来demo。
1、创建单个线程的线程池
上代码:
package com.zhan.juc.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author Zhanzhan
* @Date 2020/12/5 16:34
* Executors工具类 -- 三大方法
*/
public class ExecutorsDemo {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
// ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定大小的线程池
// ExecutorService threadPool = Executors.newCachedThreadPool();// 创建一个可伸缩的线程池
try {
for (int i = 0; i < 10; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPool.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,要关闭线程池
threadPool.shutdown();
}
}
}
运行结果:
我们可以看到,循环创建10个线程,都是同一个线程,即用此方法创建的线程池,内部是单个线程。
2、创建一个固定大小的线程池
上代码:
package com.zhan.juc.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author Zhanzhan
* @Date 2020/12/5 16:34
* Executors工具类 -- 三大方法
*/
public class ExecutorsDemo {
public static void main(String[] args) {
// ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定大小的线程池
// ExecutorService threadPool = Executors.newCachedThreadPool();// 创建一个可伸缩的线程池
try {
for (int i = 0; i < 10; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPool.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,要关闭线程池
threadPool.shutdown();
}
}
}
运行结果:
我们看到,循环10次,里面始终只有5个线程。
3、创建一个可伸缩的线程池
上代码:
package com.zhan.juc.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author Zhanzhan
* @Date 2020/12/5 16:34
* Executors工具类 -- 三大方法
*/
public class ExecutorsDemo {
public static void main(String[] args) {
// ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
// ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定大小的线程池
ExecutorService threadPool = Executors.newCachedThreadPool();// 创建一个可伸缩的线程池
try {
for (int i = 0; i < 10; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPool.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,要关闭线程池
threadPool.shutdown();
}
}
}
运行结果:
我们看到,这里循环10次,没有固定说开启了几个线程,而是根据情况,由程序自己去开启。
二、七大参数
我们首先看下,上面说的三大方法里,创建对应线程池的源码:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
我们神奇的发现,内部其实都是new 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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
这里解释下最大核心线程数:就是当核心线程全部在执行任务,并且阻塞队列里的线程也占满了队列,这时就会启动扩容核心线程,直到扩容到最大核心线程数。
那么我们就可以知道,线程池的最大承载量是多少呢?就是最大核心线程数 + 阻塞队列的容量。一旦超过这个承载量,后进入的线程就会启动拒绝策略。
上面的七个参数就是七大参数,现在我们就用ThreadPoolExectors来自定义一个线程池,并且用上这七个参数:
package com.zhan.juc.pool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Author Zhanzhan
* @Date 2020/12/5 17:08
* 七大参数、四种拒绝策略
*/
public class ThreadPoolExecutorsDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2, // 核心线程数
5, // 最大核心线程数
3, // 超时了没有人调用就会释放,指定超时时间
TimeUnit.SECONDS, // 超时单位
new LinkedBlockingQueue<>(3), // 阻塞队列,这里指定阻塞队列的容量为3
Executors.defaultThreadFactory(), // 线程工厂,一般不用动, 就使用 Executors.defaultThreadFactory()
new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略
try {
for (int i = 0; i < 8; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPoolExecutor.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPoolExecutor.shutdown(); // 线程池用完,程序结束,要关闭线程池
}
}
}
三、四种拒绝策略
我们看ThreadPoolExecutors的源码:
我们看到,RejectedExecutionHandler类是一个拒绝策略的接口类,我们进入这个类看下:
我们看到,有四个实现类,这四个实现类分别就是四种拒绝策略:
1. AbortPolicy
如果队列满了,还有线程进来,则不处理这个线程,并抛出异常;
上代码:
package com.zhan.juc.pool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Author Zhanzhan
* @Date 2020/12/5 17:08
* 七大参数、四种拒绝策略
*/
public class ThreadPoolExecutorsDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2, // 核心线程数
5, // 最大核心线程数
3, // 超时了没有人调用就会释放,指定超时时间
TimeUnit.SECONDS, // 超时单位
new LinkedBlockingQueue<>(3), // 阻塞队列,这里指定阻塞队列的容量为3
Executors.defaultThreadFactory(), // 线程工厂,一般不用动, 就使用 Executors.defaultThreadFactory()
new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略
try {
// 线程池的最大承载量 = 最大核心线程数 + 阻塞队列容量
for (int i = 0; i < 9; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPoolExecutor.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,要关闭线程池
threadPoolExecutor.shutdown();
}
}
}
我们这里让循环超过最大承载量,看运行结果:
2. CallerRunsPolicy
哪儿来的去哪儿!
上代码:
这里同样超出线程池承载量
package com.zhan.juc.pool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Author Zhanzhan
* @Date 2020/12/5 17:08
* 七大参数、四种拒绝策略
*/
public class ThreadPoolExecutorsDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2, // 核心线程数
5, // 最大核心线程数
3, // 超时了没有人调用就会释放,指定超时时间
TimeUnit.SECONDS, // 超时单位
new LinkedBlockingQueue<>(3), // 阻塞队列,这里指定阻塞队列的容量为3
Executors.defaultThreadFactory(), // 线程工厂,一般不用动, 就使用 Executors.defaultThreadFactory()
new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略
try {
// 线程池的最大承载量 = 最大核心线程数 + 阻塞队列容量
for (int i = 0; i < 9; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPoolExecutor.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,要关闭线程池
threadPoolExecutor.shutdown();
}
}
}
运行结果:
原因就是:此拒绝策略,就是超出后,从谁那里创建的,就回那里去执行,这里是main() 去创建的,所以就回去让main() 去执行此线程了。
3. DiscardOldestPolicy
队列满了,尝试和最早的竞争,如果最早的线程执行完毕,就可以跟上执行,否则则丢掉,不会抛出异常;
4. DiscardPolicy
队列满了,丢掉任务,也不会抛出异常。
上代码:
package com.zhan.juc.pool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Author Zhanzhan
* @Date 2020/12/5 17:08
* 七大参数、四种拒绝策略
*/
public class ThreadPoolExecutorsDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2, // 核心线程数
5, // 最大核心线程数
3, // 超时了没有人调用就会释放,指定超时时间
TimeUnit.SECONDS, // 超时单位
new LinkedBlockingQueue<>(3), // 阻塞队列,这里指定阻塞队列的容量为3
Executors.defaultThreadFactory(), // 线程工厂,一般不用动, 就使用 Executors.defaultThreadFactory()
new ThreadPoolExecutor.DiscardPolicy()); // 拒绝策略
try {
// 线程池的最大承载量 = 最大核心线程数 + 阻塞队列容量
for (int i = 0; i < 9; i++) {
// 使用了线程池后,就用线程池来创建线程
threadPoolExecutor.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 创建");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完,程序结束,要关闭线程池
threadPoolExecutor.shutdown();
}
}
}
运行结果:
这里丢掉了超出承载量的线程任务。
四、线程池的容量该如何定义
这里我们要考虑一个问题,就是创建线程池时,线程池的最大线程数该如何定义?是拍脑袋随便定义的吗?
这样的话可能会浪费线程资源。这个时候我们就需要找到一个定义最大线程数的方法。
1、CPU密集型
就是充分利用CPU的核数,让CPU的所有核心全部并行运算处理。
这样适用于需要大量的运算,而没有阻塞,CPU一直全速运行的场景。
所以,CPU密集型 的 最大线程数 公式为:CPU核数 + 1
这里可以使用Runtime.getRuntime().availableProcessors()
来获取当前服务器的核数,来作为最大线程数的参数。
2、I/O密集型
如果是 比较耗费 I/O 的任务场景,那么这时就需要 使用 I/O密集型 来配置线程。
我们知道,CPU的运算速度是很快的,比 I/O 的速度要快很多,那么如果是十分消耗 I/O的场景,这个时候CPU的每个单核会在很长的时间段上一直阻塞等待I/O的处理,这个时候,我们如果使用CPU密集型,给每个CPU的单核分配一个线程,这个时候CPU的单核就处于无意义的阻塞中,浪费时间,所以这个时候的最大线程数就要比CPU密集型要多。
一般我们这时的参考公式为:CPU核数 / (1 - 阻塞系数)
阻塞系数一般在 0.5 - 0.9之间,我们常用的就是 2倍CPU密集型 线程数。