作者：孙玉昌，昵称【逐个哥】，别的【壹壹哥】也是我哦

CSDN博客专家、万粉博主、阿里云专家博主、优质作者

一. 线程池的思想

咱们运用线程的时分就去创立一个线程，这样完成起来十分简便，但是就会有一个问题：

假如并发的线程数量许多，而且每个线程都是履行一个时刻很短的使命就结束了，这样频繁创立线程就会大大下降体系的功率，因为频繁创立线程和销毁线程需求时刻。

那么有没有一种办法使得线程能够复用，便是履行完一个使命，并不被销毁，而是能够继续履行其他的使命？在Java中能够经过线程池来到达这样的作用。

二. 线程池的概念

线程池： 其实便是一个包容多个线程的容器，其间的线程能够重复运用，省去了频繁创立线程目标的操作，无需重复创立线程而耗费过多资源。

三. 线程池的好处

下降资源耗费。减少了创立和销毁线程的次数，每个作业线程都能够被重复利用，可履行多个使命。

进步响应速度。当使命抵达时，使命能够不需求的比及线程创立就能立即履行。

进步线程的可管理性。能够根据体系的承受能力，调整线程池中作业线线程的数目，避免因为耗费过多的内存，而把服务器累趴下(每个线程需求大约1MB内存，线程开的越多，耗费的内存也就越大，最终死机)

四. 线程池中心 API

1. 线程池API类关系

Java里边线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个履行线程的工具。真实的线程池接口是java.util.concurrent.ExecutorService，最终完成类为ThreadPoolExecutor，如下图所示：

2.`ThreadPoolExecutor`的结构办法

ThreadPoolExecutor提供了四个结构函数(后附参数详解)：

//五个参数的结构函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)
//六个参数的结构函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)
//六个参数的结构函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)
//七个参数的结构函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

要装备一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有或许装备的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里边提供了一些静态工厂，生成一些常用的线程池。官方建议运用Executors工厂类来创立线程池目标。

3. 创立线程池的4种办法

Executors类中有个创立线程池的办法如下(四种线程池)：

public static ExecutorService newFixedThreadPool(int nThreads)：回来线程池目标。(创立的是有界线程池,也便是池中的线程个数能够指定最大数量)

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

创立缓存线程池（由使命的多少来决定）newCachedThreadPool(）

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

创立单线程池 newSingleThreadExecutor()，有且仅有一个作业线程履行使命

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

创立调度线程池（调度：按周期、守时履行）newScheduledThreadPool(int corePoolSize)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

五. 线程池参数详解

1. 中心参数

Java线程池有以下几个中心参数：

int corePoolSize： 该线程池中中心线程数最大值 。 中心线程： 线程池新建线程的时分，假如当时线程总数小于corePoolSize，则新建的是中心线程，假如超越corePoolSize，则新建的对错中心线程中心线程默许情况下会一向存活在线程池中，即使这个中心线程啥也不干(搁置状况)。假如指定ThreadPoolExecutor的allowCoreThreadTimeOut这个特点为true，那么中心线程假如不干活(搁置状况)的话，超越一守时刻(时长下面参数决定)，就会被销毁掉。

int maximumPoolSize： 该线程池中线程总数最大值 。线程总数 = 中心线程数 + 非中心线程数。

long keepAliveTime： 该线程池中非中心线程搁置超时时长 。一个非中心线程，假如不干活(搁置状况)的时长超越这个参数所设定的时长，就会被销毁掉，假如设置allowCoreThreadTimeOut = true，则会作用于中心线程。

TimeUnit unit： keepAliveTime的单位。TimeUnit是一个枚举类型，包括：NANOSECONDS：1微毫秒 = 1微秒 / 1000 MICROSECONDS：1微秒 = 1毫秒 / 1000 MILLISECONDS：1毫秒 = 1秒 /1000 SECONDS：秒 MINUTES：分 HOURS：小时 DAYS：天

BlockingQueue workQueue： 该线程池中的使命行列：维护着等候履行的Runnable目标。当所有的中心线程都在干活时，新增加的使命会被增加到这个行列中等候处理，假如行列满了，则新建非中心线程履行使命。

2. 常用的workQueue类型

SynchronousQueue：这个行列接纳到使命的时分，会直接提交给线程处理，而不保留它，假如所有线程都在作业怎么办？那就新建一个线程来处理这个使命！所以为了确保不呈现<线程数到达了maximumPoolSize而不能新建线程>的过错，运用这个类型行列的时分，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大。

LinkedBlockingQueue：这个行列接纳到使命的时分，假如当时线程数小于中心线程数，则新建线程(中心线程)处理使命；假如当时线程数等于中心线程数，则进入行列等候。因为这个行列没有最大值限制，即所有超越中心线程数的使命都将被增加到行列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永久不会超越corePoolSize。

ArrayBlockingQueue：能够限定行列的长度，接纳到使命的时分，假如没有到达corePoolSize的值，则新建线程(中心线程)履行使命，假如到达了，则入队等候，假如行列已满，则新建线程(非中心线程)履行使命，又假如总线程数到了maximumPoolSize，而且行列也满了，则发生过错。

DelayQueue：行列内元素必须完成Delayed接口，这就意味着你传进去的使命必须先完成Delayed接口。这个行列接纳到使命时，首要先入队，只要到达了指定的延时时刻，才会履行使命。

ThreadFactory threadFactory： 创立线程的方式，这是一个接口，你new他的时分需求完成他的Thread newThread(Runnable r)办法，一般用不上。

RejectedExecutionHandler handler： 抛出反常专用的，比如上面说到的两个过错发生了，就会由这个handler抛出反常。

六. 线程池的履行战略

当一个使命被增加进线程池时，会履行以下战略：

线程数量未到达corePoolSize，则新建一个线程(中心线程)履行使命；

线程数量到达了corePools，则将使命移入行列等候；

行列已满，新建线程(非中心线程)履行使命；

行列已满，总线程数又到达了maximumPoolSize，就会由(RejectedExecutionHandler)抛出反常。

假如咱们获取到了一个线程池ExecutorService目标，又该怎么运用呢？咱们能够在这里界说一个运用线程池目标的办法，如下所示：

public Future<?> submit(Runnable task)：获取线程池中的某一个线程目标，并履行使命。

public <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程目标，并履行使命。

这里的Future接口，带有回来值，能够用来记载线程使命履行完毕后产生的成果。

七 . ****线程池的运用

1. 运用过程

假如咱们要运用线程池中的线程目标，主要是遵从如下几个过程：

创立线程池目标；

创立Runnable/Callable接口子类目标；

提交Runnable/Callable接口子类目标；

封闭线程池(一般不做)。

2. 代码事例

以下是线程池的运用事例：

public class ExecutorServiceDemo {
    public static void main(String[] args) throws Exception {
        //获取到了线程池  固定长度的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(100);
        //可缓存的线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        //单例线程池
        //ExecutorService fixedThreadPool = Executors.newSingleThreadExecutor();
        //使命调度线程池
        // ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //创立使命
        MyCallable myCallable =new MyCallable();
        Future<String> submit = fixedThreadPool.submit(myCallable); //future代表的是线程履行之后的回来成果
        fixedThreadPool.submit(myCallable);//履行使命
        fixedThreadPool.submit(myCallable);
        fixedThreadPool.submit(myCallable);
        fixedThreadPool.submit(myCallable);
        //封闭线程池  服务端线程池是不能封闭的
        //fixedThreadPool.shutdown();
    }
}
//callable能够得到线程的回来值
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"call使命履行了");
        Thread.sleep(2000);
        System.out.println(Thread.currentThread().getName()+"call履行完毕");
        return "qfedu";
    }
}

现在你知道Java中的线程池是怎么回事了吗？假如你还有其他问题，能够在谈论区留言哦。

Java的线程池是怎么回事？来看看这篇文章吧

一. 线程池的思想

二. 线程池的概念

三. 线程池的好处

四. 线程池中心 API

1. 线程池API类关系

2.`ThreadPoolExecutor`的结构办法

3. 创立线程池的4种办法

五. 线程池参数详解

1. 中心参数

2. 常用的workQueue类型

六. 线程池的履行战略

七 . ****线程池的运用

1. 运用过程

2. 代码事例

作者信息

推广

Java的线程池是怎么回事？来看看这篇文章吧

一. 线程池的思想

二. 线程池的概念

三. 线程池的好处

四. 线程池 中心 API

1. 线程池API类关系

2.ThreadPoolExecutor的结构办法

3. 创立线程池的4种办法

五. 线程池参数详解

1. 中心参数

2. 常用的workQueue类型

六. 线程池的 履行 战略

七 . ****线程池 的 运用

1. 运用过程

2. 代码事例

相关文章

findViewById不香吗？为什么要把简单的问题复杂化？为什么要用DataBinding？

MediaPlayer的核心-NuPlayer

Typescript：不能依赖修饰符private来隐藏信息

分布式锁主动续期的入门级实现-自省 | 简约而不简单

作者信息

推广

四. 线程池中心 API

2.`ThreadPoolExecutor`的结构办法

六. 线程池的履行战略

七 . ****线程池的运用