JAVAEE-8-线程池

池

我们之前也接触过,比如说常量池,数据库连接池,线程池,进程池,内存池等等,

池的共性:

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

运行结果?