线程池和常见锁策略

江鱼鳍

已于 2023-08-05 16:56:20 修改

阅读量316

点赞数

文章标签： java 开发语言

于 2023-08-05 01:43:06 首次发布

本文链接：https://blog.youkuaiyun.com/qq_40841463/article/details/132103873

版权

线程池

池(pool)是一个非常重要的思想方法

内存池

进程池

链接池

常量池......这些"池"概念上都是一样的

如果我们需要频繁的创建销毁线程,此时创建销毁线程的成本就不能忽视了,因此我们可以使用线程池,线程池就是提前创建好一波线程,后续需要使用线程就从池子里拿就行,当线程不再使用,就放回池子里,把创建销毁线程变成从池子里拿和归还线程

但是为啥从池子里取会比创建线程更快更高效呢?

因为如果是从系统这里创建线程,就需要调用系统的API,进一步又操作系统内核完成线程创建的过程(内核是给所有进程提供服务的,谁知道啥时候轮到你,这是不可控的), 但是如果是从线程池这里获取线程,上述的内核中进行的操作,都提前做好了,现在的取线程的过程,纯粹的用户代码完成的(纯用户态),这是用户自己控制的,是可控的

Java的标准库中,也提供了现成的线程池

等号左边是线程池对象,等号右边是创建线程池对象的过程,其中Executors称为"工厂类",而newFixedThreadPool是"工厂方法",这个4是线程数量

这里我们就涉及到一个模式,工厂模式,工厂,顾名思义,就是生产对象的意思,我们一般创建对象都是通过new并且通过构造方法,但是构造方法存在重大缺陷,这个缺陷就是:构造方法的名字固定就是类名,但是有的类,需要有多种不同的构造方式,但是构造方法名字又固定,就只能使用方法重载的方式来实现了,重载的参数的个数和类型需要有差别.此时我们就可以使用工厂模式解决上述问题

举个缺陷的例子,这是一个点,描述一个点可以通过坐标或者极坐标

class Point{ //两种构造方法

publicPoint(double x,double y){}; //通过坐标的构造方法

publicPoint(double x,double y){}; //通过极坐标的构造方法

}

这两种构造方式,参数的个数和类型是一样的,无法构成重载

我们可以使用工厂模式解决上述问题,不用构造方法了,使用普通的方法来构造对象,这样的方法名字就可以是任意的了,然后普通方法内部我们再来new对象,然后由于普通方法目的是为了创建出对象来,这样的方法一般得是静态的

class Point{

public static makePointXY(double x,double y){};

public static makePointRA(double x,double y){};

}

此时我们想new一个对象就可以:Point p = Point makePointXY(10,20);

上面的代码我们就称之为工厂模式,这两个方法我们称之为工厂方法

下面我们看看几个创建线程池的方法

ExecutorService service = Executors.newFixedThreadPool(4);
Executors.newCachedThreadPool();//创建出一个线程数目动态变化的线程池
Executors.newSingleThreadExecutor();//包含单个线程,比原生的线程API要更简单一点
Executors.newScheduledThreadPool();//类似于定时器的效果,添加一些任务,任务都在后续的某个时刻再执行,被执行的时候,不止一个扫描线程来执行任务,可能有多个线程来执行任务,类似于一个线程分几个任务

线程池对象搞好了之后,使用submit方法,就可以把多个任务添加到线程池中,看代码

public class Demo23 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(4);
        for (int i = 0;i < 1000;i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }
    }
}

,线程池中有四个线程,这四个线程就会合力把我们分配的1000个任务一起完成

除了上述这些线程池之外,标准库还提供了一个接口更丰富的线程池类

ThreadPoolExecutor

上面那四个线程池都是针对ThreadPoolExecutor这个原生的类进行的封装,这四个线程池为了使用方便,已经做了一层封装了

这个原生的线程池提供的接口非常丰富,有很多供我们调整的选项,能更好地满足需求

经典面试题,谈谈Java标准库里的线程池构造方法的参数和含义

ThreadPoolExecutor 里面的线程个数,并非是固定不变的,会根据当前任务的情况动态发生改变

这样既能保证繁忙的时候高效地处理任务,又能保证空闲的时候不会浪费资源

int corePoolSize 核心线程数(意思是线程池中至少要有这么多线程,哪怕没有任务)

int maximumPoolSize 最大线程数(意思是最多不能超过这些线程,哪怕线程池冒烟了)

long KeepAliveTime (时间),TimeUnit unit (时间单位),假如设定是3000ms,那么线程空闲时间超过3000ms就会被销毁

BlockingQueue<Runnable> workQueue 线程池内部有很多任务,这些任务,可以使用阻塞队列来管理

线程池可以内置阻塞队列,也可以手动指定一个

ThreadFactory ThreadFactory 工厂模式,通过这个工厂类来创建线程

RejectedExecutionHandler handler 线程池考察的重点,也叫作拒绝方式/拒绝策略,线程池有一个阻塞队列,当阻塞队列满了以后,继续添加任务,该如何应对

第一个应对方法:ThreadPoolExecutor.AbortPolicy (直接抛出异常,线程池就不干活了)

第二个应对方法:ThreadPoolExecutor.CallerRunsPolicy (谁是添加这个新任务的线程,就谁去执行这个任务,把任务丢回去)

第三个应对方法:ThreadPoolExecutor.DiscardOldestPolicy (丢弃最早的任务,执行新的任务)

第四个应对方法:ThreadPoolExecutor.DiscardPolicy (直接丢弃新的任务)

上面谈到的线程池有两组,一组是封装过的,Executors

一组是原生的,ThreadPoolExecutor

用哪个都可以,主要还是看实际的需求

但是有的公司更建议用原生的,因为更直观,每一个方面怎么设定的在构造方法都有体现

接下来我们要自己实现一个线程池

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

class MyThreadPool{
    private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();//用阻塞队列来保存若干个任务
    //通过这个方法,把任务添加到线程池中
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
    //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) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
}
public class Demo24 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(4);
        for (int i = 0;i < 1000;i++){
            pool.submit((new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            }));
        }
    }
}

运行结果就是打印了1000个hello,这1000个hello都是由线程池这四个线程一起打印出来的,并且是随机的