1.什么是线程池
线程存在的意义是当使用进程进行并发编程太重了,此时引入了一个"轻量级的"进程-线程.
创建线程比创建进程更高效,销毁线程比销毁进程更高效,调度线程比调度进程更高效..此时我们就用多线程来代替进程进行并发编程了,但是随着对性能的要求的提高,线程相对来说又变"重"了,在我们频繁创建和销毁线程是,也有很大的开销
因此我们为了进一步提高效率,提出了两种办法
第一种:类似于进程和线程,我们创建一个"轻量级线程”-协程/纤程(这种方法还没有加入到java标准库中)
第二种:使用线程池,来降低创建/销毁线程带来的开销
线程池就是和字符串常量池,数据库连接池相同的道理,事先把需要用的线程创建好,放到线程池中,后面需要使用的时候,直接从池中获取,如果用完了,就还给线程池..这两个操作是比创建线程/销毁线程要更加高效的!!
线程池的好处:减少每次启动,销毁线程的损耗
创建线程/销毁线程是交由操作系统内核完成的,从线程池获取/交还是由用户代码能实现的,不必交给操作系统内核
相比于操作系统内核来说,用户态程序的执行更为可控,想要执行某个任务(从线程池取线程,还线程)会很快的就完成了,如果通过操作系统内核创建线程,销毁线程,需要通过系统调用,让内核来执行,但是内核身上背负的是整个计算机的活动,服务的是所有应用程序,整体过程是"不可控的”,因此使用线程池更为高效!
2.标准库中的线程池
在Java标准库中也提供了线程池可以直接使用
标准库中提供了很多种创建线程池的方式,这里提供一种简单的方式创建线程池
线程池里的线程数目是十个
我们在上述代码中并没看见new关键字,此处的new是方法名字的new,不是关键字
这里相当于直接使用类的静态方法创建出的对象,相当于把new操作给隐藏到这样的方法后面了.这种方法就成为"工厂方法”,提供这个方法的类,称为"工厂类”,此处这个代码使用的是"工厂设计模式”,下来我们了解一下什么是"工厂模式”
工厂模式
工厂模式:使用普通的方法来代替构造方法,创建对象(构造方法只能构造一种对象,如果要构造不同情况的对象,就很难了)
举个例子:我们要使用xy直角坐标系和ra极坐标系确定一个点时,要创造两种不同的对象
class Point{
public Point(double x,double y) {
}
public Point(double r,double a) {
}
}
很明显这个代码是有问题的,编译器报错,正常来说,多个构造方法是"重载"的方式来提供的,重载要求:方法名相同,参数的个数或者类型不相同,为了解决这个问题,可以使用工厂模式
class Point{
public static Point makePointByXY(double x,double y) {
}
public static Point makePointByRA(double r,double a) {
}
}
此时我们就可以使用普通方法来创建对象,因此多种方法构造,直接使用不同的方法名就行,参数就不用再区分了!
我们继续说线程池部分的知识
构建好十个线程后我们就可以利用线程来完成任务,线程池提供了一个重要的方法-submit,可以给线程池提供若干个任务.
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
运行程序我们发现:主线程结束了,整个进程还没有结束,线程池中的线程都是前台线程,此时会阻止进程结束(定时器也是如此)
我们创建多个任务提交
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {
int n = i;
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello "+n);
}
});
}
}
这1000个任务就是由十个线程一起完成的,差不多是一个线程执行一百个,不是严格的一个一百,由于每个任务时间差不多,因此每个线程执行的数量也差不多.这个操作类似于排队做核酸,核酸点人数都差不多,做核酸速度也差不多,因此相同时间大概完成的数量是相同的!
lamada表达式的变量捕获
还有个问题,能不能不定义n
实际上是不行的,会出现这个错误:
这个语法规则和lamada表达式的变量捕获有关.
此处的run方法属于Runnable.这个方法的执行时机不是立即执行,而是在未来的某个时间节点上(后续的线程池队列中,排队到他了就去执行)
变量i是主线程 的局部变量,随着主线程执行结束,他就销毁了,很可能主线程的for循环执行完了,当前run的任务在线程池中没排到,这是i已经销毁了
为了避免执行run的时候i已经销毁,于是就有了变量捕获,也就是让run方法把刚才的主线程的i给当前run的栈上拷贝一份(在定义run的时候偷偷记住一分i,后续执行run的时候,也创建一个i的局部变量,并且赋值给n)
这个过程称为变量捕获,是为了抹平生命周期的差异,i本来跟着主线程的生命周期走,但run方法实际在主线程生命周期之外还需要使用i,所以需要进行一份拷贝
在Java中,对变量捕获作了一些额外的要求,JDK1.8之前,要求只能捕获final修饰的变量,1.8开始.放松了标准,只要代码中没有修改这个变量,也可以捕获.此处i是有修改的,但是n没有修改可以捕获
Executors这个工厂类给我们提供了很多种风格的线程池
Executors.newCachedThreadPool()
这个线程池的线程数量是动态可变的,如果任务多了,就多增加几个线程,线程少了,就少创建几个线程
Executors.newSingleThreadExecutor()
这个线程池里只有一个线程,用的比较少
Executors.newScheduledThreadPool()
类似于定时器,也是让任务延时运行,只不过执行的时候不是由扫描线程自己执行,而是由单独的线程池来执行
这几种线程池本质都是通过包装ThreadPoolExexutor来实现的
这个线程池用起来比较麻烦,所以才提供了工厂类,让我们使用起来简便,这也意味着它本身的功能更强大
ThreadPoolExexutor类
java.util.concurrent这个包中的很多类都是和并发编程(多线程编程)密切相关的,也成为JUC
打开这个包,找到
找到该类提供的构造方法
第四个版本参数,方法是最多的.我们逐个分析
int corePoolSize
这个参数是核心线程数
int maximumPoolSize
这个参数是最大线程数
ThreadPoolExexutor相当于把里面的线程分为两类
一类是正式工(核心线程数),一类是临时工,两个加起来就是最大行程数
允许正式员工摸鱼,临时工不能摸鱼,临时工摸鱼就会被开除(销毁)!!
如果任务很多,那么我们就要更多的线程来完成,但一个程序的任务有时多有时少,少时我们需要对现有的线程进行一定的销毁..原则时正式工(核心线程)留着,临时工动态调节!实际开发时线程池中的线程设置为多少(N(cpu核数),N+1,1.5N,2N….)是不准确的,面试遇到,回答具体数字那么肯定是答错了..
对不同的程序,需要设置的线程数也是不同的
需要考虑两个极端情况:
CPU密集型
每个线程执行的任务都是需要使用CPU的,此时线程池线程数最多不应该超过CPU核数,设置的更大也无效.因为cpu就那么多
IO密集型
每个线程干的工作就是等待IO(读写硬盘,读写网卡,等待用户输入….),不多占用CPU,此时线程处于阻塞状态,不参与调度,这是线程数多一点也没事,不再受制于CPU的核数了.
然而实际开发种.往往一部分吃cpu,一部分等待IO,所以要在实践中确定线程数量,通过测试/实验来确定!!
long keepAliveTime, TimeUnit unit,
这两个参数描述了临时工摸鱼的最大时间…如果超过这个时间,线程就被销毁了!
BlockingQueue<Runnable> workQueue
这个是线程池的任务队列.此处使用阻塞队列,若没有任务,就阻塞,有就take成功…
ThreadFactory threadFactory
用于线程池创建线程
RejectedExecutionHandler handler
描述了线程池的"拒绝策略”..也是一个特殊的对象,描述了当线程池任务队列满了,如果继续添加任务会有什么行为
看看标准库提供的拒绝策略:
第一种:如果任务太多,队列满了,直接抛出异常
第二种:如果队列满了,多出来的任务,谁添加的谁负责执行
第三种:如果队列满了,丢弃最早的任务
第四种:丢弃最新的任务
针对ThreadPoolExexutor的参数的解释是高频的面试题,需要牢记
3.实现线程池
一个线程池,要有一个阻塞队列,保存任务.还要有若干个工作线程
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class Test {
public static void main(String[] args) throws InterruptedException {
MyThreadPool myThreadPool = new MyThreadPool(10);
for (int i = 0; i < 1000; i++) {
int n = i;
myThreadPool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello"+n);
}
});
}
}
}
class MyThreadPool{
private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
//n表示线程数
public MyThreadPool(int n){
for (int i = 0; i < n; i++) {
Thread t = new Thread(()->{
while(true){
try {
Runnable runnable = queue.take();
runnable.run();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
}
}
//注册任务线程池
public void submit(Runnable runnable) throws InterruptedException {
queue.put(runnable);
}
}
原文链接: https://blog.csdn.net/chenchenchencl/article/details/128641887