线程池

最新推荐文章于 2022-03-28 10:08:21 发布

小码农eve

最新推荐文章于 2022-03-28 10:08:21 发布

阅读量374

点赞数

分类专栏： Thread 文章标签：线程池多线程线程

本文链接：https://blog.csdn.net/cdw8131197/article/details/54021198

版权

Thread 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

线程池

Executors是个线程的工厂类，方便快速地创建很多线程池，也可以说是一个线程池的工具类。在Executors类里面提供了一些静态工厂，
生成一些常用的线程池。常用的方法有以下三种：
1、newSingleThreadExecutor：创建一个单线程的线程池
2、newFixedThreadPool：创建固定大小的线程池
3、newCachedThreadPool：创建一个可缓存的线程池

newSingleThreadExecutor的使用

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，
那么会有一个新的线程来代替它。此线程池保证所有的任务的执行顺序按照任务的提交顺序执行。
示例：

package com.cn.test.other;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsTest {

    public static void main(String[] args) throws InterruptedException {

        //创建一个单线程的线程池
        ExecutorService es = Executors.newSingleThreadExecutor();

        for(int i=0;i<10;i++){
            final int no =i;
            Runnable runable = new Runnable(){
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    try {
                        System.out.println("into========"+no);
                        Thread.sleep(1000);
                        System.out.println("end========"+no);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            es.execute(runable);
        }
        Thread.sleep(2000);
        es.shutdown();
        System.out.println("Thread Main end!");
    }
}

运行结果：
这里写图片描述

jvm监控：
这里写图片描述

当运行程序是，已启动的线程数加1后固定。
从运行结果可以看出，线程池中有且只有一个线程在活动，当线程终止后会新建另一个线程继续执行任务

Executors.newSingleThreadExecutor()的实现方法：

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

上述代码根据ThreadPoolExecutor创建一个LinkedBlockingQueue的1个大小的线程池，采用的是默认的异常策略

newCachedThreadPool的使用

线程池中有可用的线程则使用，如果线程池中没有可用的线程，则新建一个线程并添加到缓存线程池中。终止时从缓存中移除那些已有60s未被使用的线程。
因此，长时间保持空闲的线程池不会使用任何资源。

示例：

package com.cn.test.other;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsCachedThreadPoolTest {

    public static void main(String[] args) throws InterruptedException {
        //创建一个单线程的线程池
        ExecutorService es = Executors.newCachedThreadPool();

        for(int i=0;i<20;i++){
            final int no =i;
            Runnable runable = new Runnable(){
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    try {
                        System.out.println("into========"+no);
                        Thread.sleep(20000);
                        System.out.println("end========"+no);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            es.execute(runable);
        }
        Thread.sleep(2000);
        es.shutdown();
        System.out.println("Thread Main end!");
    }
}

运行结果：
这里写图片描述

JVM监控结果：
这里写图片描述

从运行结果和监控结果可以看出，开始时线程数会增加很多，使用完成后，线程数急剧下降

Executors.newCachedThreadPool()的实现

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

代码创建了一个内核线程池。线程为零，来一个线程就在线程池里面创建一个SynchronousQueue；

newFixedTreadPool的使用

创建一个可重用的固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数nThreads线程会处于处理任务的活动状态。
如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。
如果在线程执行期间由于失败而导致任何线程终止，那么一个新的线程将代替他执行后续任务。在某个线程被现实地关闭之前，池中的线程将一直存在。

示例：

package com.cn.test.other;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsFixedThreadPoolTest {

    public static void main(String[] args) throws InterruptedException {
        //创建一个单线程的线程池
        ExecutorService es = Executors.newFixedThreadPool(5);

        for(int i=0;i<20;i++){
            final int no =i;
            Runnable runable = new Runnable(){
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    try {
                        System.out.println("into========"+no);
                        Thread.sleep(2000);
                        System.out.println("end========"+no);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            es.execute(runable);
        }
        Thread.sleep(2000);
        es.shutdown();
        System.out.println("Thread Main end!");
    }
}

运行结果：
这里写图片描述

JVM监控结果：
这里写图片描述

从运行结果和监控结果可以看出，当创建5个线程后，线程数量将不再增加。

线程池的好处

合理利用线程池带来的4个好处
1、降低资源消耗。通过重复利用已经创建的线程，降低线程创建和销毁造成的消耗；
2、提高响应速度。当任务到达时，任何可以不需要等到线程创建就能立即执行；
3、提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控；
4、防止服务器过载，形成内存溢出，或者CPU耗尽；

线程池的应用范围

1、需要大量的线程来完成任务，且完成任务的时间比较短。Web服务器完成网页请求这样的任务，使用线程池技术非常的合适。
因为单个任务小，而任务数量巨大。对于长时间的任务，比如一个Telnet链接请求，线程池的有点久不明显了。因为Telnet的会话时间比线程的创建时间打多了；
2、对性能要求苛刻的应用，比如要求服务器迅速响应客户请求；
3、接受突发性的大量请求，但不至于使服务器产生大量线程的应用。短时间内产生大量线程可能使内存达到极限，并出现OutOfMamory错误；

线程池的工作机制及原理

线程池的核心两个队列：
1、线程等待池，即线程队列BlockingQueue;
2、任务处理池，即正在工作的Thread列表(HashSet);

线程池的核心参数：
1、核心池大小（corePoolSize），即固定大小，设定好之后，线程池的稳定峰值，达到这个值之后池的线程数大小不会释放的
2、最大处理线程池数（maximumPoolSize），当线程池里面的线程数超过corePoolSize，小于maximumPoolSize时会动态创建与回收线程池里面的线程资源

ExecutorService的主要家族
Executor：线程池的顶级接口，但是从严格意义上来讲，Executor并不是一个线程池。而是一个执行现成的工具；
ExecutorService：真正的线程池接口。这个接口继承了Executor接口，并声明了一些方法；如shutdown、shutdownNow、submit、invokeAll等等；
AbstractExecutorService：实现了ExecutorService接口，其实实现了ExecutorService接口声明的所有方法；
ThreadPoolExecutor：ExecutorService的默认实现，继承了类AbstractExecutorService；
ScheduledExecutorService：与Timer/TimerTask类似，解决那些需要重复执行的问题；
ScheduledThreadPoolExecutor：继承ThreadPoolExecutor，并实现ScheduledExecutorService接口；

如果线程池的线程已经饱和，并且任务队列也已满，那么就需要做丢弃处理，RejectedExecutionHandler这个类就是用来处理被丢弃的线程的异常处理接口
接口内容如下：

public interface RejectedExecutionHandler {

    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

可以自己实现这个接口，实现自己的线程丢弃处理类

JDK里面RejectedExecutionHandler提供了4种方式来处理任务拒绝策略：
AbortPolicy：直接抛出异常；
CallerRunsPolicy：只用调用者所在的线程来运行任务；
DiscardOldestPolicy：丢弃队列里面最近的一个任务，并执行当前任务；
DiscardPolicy：不处理不丢弃；

为什么会有拒绝的情况发生：
这里先假设一个前提：线程池有一个任务队列，用于缓存所有待处理的任务，正在处理的任务将从任务队列中移除。
因此，在任务队列长度有限的情况下，就会出现新任务的拒绝处理问题，需要有一种策略来处理这种应该加入任务队列却因为
队列已满无法加入的情况。另外，在线程池关闭的时候，也需要对任务加入队列操作进行额外的协调处理；

ThreadPoolExecutor详解
这个类的四种构造方法：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

通过观察每个构造器的源码的具体实现，发现前面三个构造器都是调用第4个构造器进行初始化工作的。也可以说这是一个真正的构造方法。
参数解释：
int corePoolSize：核心池的大小，在创建线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来时才创建线程去执行任务，
除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这两个方法的名字就可以看出，是预创建线程的意思，
即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程后，线程池中的线程数为0，当有任务来之后，
就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
int maximumPoolSize：线程池的最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；在corePoolSize
和maximumPoolSize之间的线程数会被自动释放。而小于corePoolSize的不会；
long keepAliveTime：表示线程没有任务执行时最多保持多长时间会终止。默认情况下，只有当线程中的线程数大于corePoolSize时，keepAliveTime
才会起作用，知道线程池中的线程到keepAliveTime，则会终止。直到线程池中的线程数不大于corePoolSize。但是若果调用了
allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，知道线程池中的线程数为0；
TimeUnit unit：参数keepAliveTime的时间单位，一个JDK里面的时间单位枚举类；
BlockingQueue<Runnable> workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行产生重大影响。
一般来说这种阻塞队列有以下几种选择（ArrayBlockingQueue;LinkedBlockingQueue;SynchronousQueue）；
ThreadFactory threadFactory：线程工厂，主要用来创建线程；可以自定义一个线程工厂。默认的就是Executors.defaultThreadFactory()。
用来在线程池里面创建线程；
RejectedExecutionHandler handler：表示当拒绝处理任务时的策略，也是可以自定义的，默认也是我们前面说的4种取值
ThreadPoolExecutor.AbortPolicy(默认的)
ThreadPoolExecutor.DiscardPolicy
ThreadPoolExecutor.DiscardOldestPolicy
ThreadPoolExecutor.CallerRunsPolicy

线程池在工作中错误使用

1、分不清楚线程池是单例还是多对象。线程池一定要在合理的单例模式下才生效，若是在services方法里面创建线程池是不可以的。因为这个方法被调用的时候不是
创建了多少个线程的问题了，而是创建出来一大堆线程池了
2、线程池数量设置很大，请求过载。
3、注意死锁的问题

Spring整合线程池配置示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.1.xsd
    ">
    <bean id="taskExecutor"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 线程池维护线程的最少数量 -->  
        <property name="corePoolSize" value="5" />
        <!-- 线程池维护线程的最大数量 -->  
        <property name="maxPoolSize" value="12" />
        <!-- 线程池维护线程所允许的空闲时间 -->  
        <property name ="keepAliveSeconds" value ="30000" />  
        <property name="WaitForTasksToCompleteOnShutdown" value="true" />
        <!-- 线程池所使用的缓冲队列 -->
        <property name ="queueCapacity" value ="200" />  
    </bean>

</beans>