多线程案例-线程池-蒲公英云

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