池
我们之前也接触过,比如说常量池,数据库连接池,线程池,进程池,内存池等等,
池的共性:
1.提前把要用的对象准备好
2.把用完的对象也不要立即释放,先留着以备下次使用
来提高效率!!!
最开始,进程能够解决并发编程的问题,因为频繁创建销毁进程的开销成本太大了,所以我们引进了轻量级进程===>线程.
如果销毁线程的频率进一步增大,那么此时线程的创建销毁开销成本,就不能再被无视了.
优化线程的创建销毁效率:
解决方案:
1.引入轻量级线程==>也称为纤程/协程
协程本质,是程序员在用户态代码进行调度,不是靠内核的调度器调度的,节省了很多调度上的开销.
协程是在用户代码中,基于线程封装出来的.有可能是n个协程对应着一个线程,也有可能是n个协程对应着M个线程.
2.线程池:
把要使用的线程提前创建好,用完了也不要直接释放而是以备下次使用,就节省了创建/销毁线程的开销.在这个使用的过程,并没有真的频繁创建销毁,而只是从线程池里,取线程使用,用完了放回线程池里而已.
从线程池里取代码,纯用户态代码,是可控的.
通过系统申请创建线程,就需要内核来完成的.(不太可控).
标准库中的线程池:
ThreadPoolExecutor
int corePoolSize 核心线程数:一个线程池里最少得有多少个线程
/**标准库中提供的线程数量并非是一成不变的.而是会根据当前任务量,自适应线程个数,任务多了,线程就会多几个,任务少了,线程就会少几个
int maximumPoolSize 最大线程数,一个线程池里,最多能有多少个线程
keepAliveTime是保持存活时间,成为实习生线程,就是允许最大的空闲摸鱼时间,如果当前的这个实习生线程,空闲超过了这个时间阈值,就会被销毁掉,
unit 单元变量,s/min/hour/ms
Runnable,作为描述任务的主体,和定时器类似,线程池中也可以有多个任务,也可以设置PriorityBlockingQueue,带有优先级
线程工厂,-->工厂模式,也是一种常见的设计模式.通过专门的"工厂类"/"工厂对象"来创建制定的对象
在这个类里面提供了方法(也不一定非得是静态的)
让方法封装了new操作,并且同时给Thread设置了一些属性,才构成了ThreadFactory线程工厂
工厂模式解析
//举例,表示平面上的一个点
class Point{
public Point(double x,double y);//通过笛卡尔积来初始化
public Point(double r,double a)';//通过极坐标来初始化
因为上述代码无法通过编译,所以我们设计工厂模式来解决上述问题}
class Point{
public static PointMakeByXY(double x,double y){
Point p=new Point();
p.setX(x);
p.setY(y);
}
public static PointMakeByra(double r,double a){
Point p=new Point();
p.setR(r);
p.setA(a);
}
Point p1=Point.PointMakeByxy(x,y);
Point p2=Point.PointMakeByra(r,a);
//工厂模式的核心思路,使用一些类或者对象来使用静态方法对new操作进行封装,然后再去单独的去设置他的一些属性,在方法内部设定不同的属性来完成对象的初始化,构造对象的过程.来达到我们想要的结果.
拒绝策略;
在线程池里,有一个阻塞队列,能够容纳的元素有上限,当任务队列已经满了的时候,如果继续往队列中添加任务,线程池会怎么办?
第一个,AbortPolicy:如果继续添加任务,他会直接抛出异常RejectedExecutionException,导致新的任务无法完成,旧的任务也无法完成了.
第二个:CallerRunsPolicy,新的任务,由添加任务的线程来负责执行,就是调用这个方法的线程去完成,不是线程池完成
第三个:DiscardOldesPolicy,丢弃最老的任务,新增加的任务会由线程池执行
第四个:DiscardPolicy,会把最新的任务丢弃掉,谁也不去执行,调用的线程不执行,线程池也不去执行.
ThreadPoolExecutor本身比较复杂,因此标准库提供了另外一个版本,把ThreadPoolExecutor进行了封装,封装成Executors,工厂类.通过这个类来创建出不同的线程池对象(在内部把ThreadPoolExecutor创建好了并且设置了不同的參数)
ExecutorService service=Executors.newFixedThreadPool(4);
service.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});我们在实际开发中,创建线程池的时候,很多时候都需要去设定线程池的线程数量.
不同的程序,能够设定的线程的数量是不同的,必须要具体问题具体分析.
我们要判断一个线程是CPU密集型的任务还是IO密集型的任务.
对于CPU密集型的任务(这个线程大部分时间都要在CPU上运行,进行计算)
对于IO密集型任务(这个线程大部分的时间都在等待IO,不需要去CPU上运行),比如线程run,scanner,读取用户的输入.
如果一个进程中,所有的线程都是CPU密集型的,每个线程所有的工作都是CPU上执行的.(极端情况)
此时,线程数目就不该超过N(cpu逻辑核心数)
如果一个进程中,所有的线程都是IO密集型的,每个线程的大部分工作都是在等待IO,cpu消耗非常少,此时的线程数目就可以很多,远远超过N.
上述两个情况都是极端情况,在实际开发中,大概率是一部分是IO一部分是CPU的.
这里的比例,需要我们通过具体的实验测试出来.
综上,由于程序的复杂性,很难直接对于线程池的线程数目进行估算.
更适合的做法,通过实验/测试的方式来找到合适的线程数目.
尝试给线程池,设定不同的线程数目,分别进行性能测试.
衡量每种线程数目下,总的时间开销,和系统资源占用的开销,找到这两者之间合适的值.
自定义线程池创建
class MyThreadPoolExecutor{//自定义线程池
private ArrayList<Thread>threadArrayList=new ArrayList<>();
//用来存储后续设定的线程,方便后续处理
private BlockingQueue<Runnable> queue=new ArrayBlockingQueue<>(4);
//用来存储执行任务的队列
public MyThreadPoolExecutor(int n){//n为线程池创建出来的线程数目
for(int i=0;i<n;i++){
Thread t=new Thread(()->{
while(true){
try {
Runnable runnable=queue.take();//取出需要执行的任务,这里的队列使用take,是带有阻塞功能的
runnable.run();//取出来之后进行使用
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
threadArrayList.add(t);
t.start();
}
}
public void submit(Runnable runnable) throws InterruptedException {
queue.put(runnable);//这里进行放入任务
}
}测试代码
public class Main {
public static void main(String[] args) throws InterruptedException {
MyThreadPoolExecutor executor=new MyThreadPoolExecutor(4);
for(int i=0;i<1000;i++){
int n=i;//因为变量捕获
executor.submit(new Runnable() {
@Override
public void run() {
System.out.println("执行任务"+n+"线程为"+Thread.currentThread().getName());
}
});
}
}
}
运行结果
![[pasecactf_2019]flask_ssti proc ssti config](https://img-blog.csdnimg.cn/direct/27ecee9fd93f4ccf865cefcdfb268ce3.png)
