Java并发编程：线程池的原理

最新推荐文章于 2018-09-03 22:32:30 发布

置顶哪里都有好故事

最新推荐文章于 2018-09-03 22:32:30 发布

阅读量182

点赞数 2

分类专栏： .Java并发编程与高并发 java笔试面试

本文链接：https://blog.csdn.net/qq_35387891/article/details/80142201

版权

java笔试面试同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

.Java并发编程与高并发

7 篇文章 0 订阅

订阅专栏

为什么我们要用线程池？

1.如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。
假如创建一个线程消耗时间为T1，执行任务消耗时间T2，销毁线程消耗时间T3。
如果T1+T3 > T2，线程用来创建和销毁的时间大于了执行任务的时间，那么开启一个线程来执行这个任务太不值得了。
线程池缓存线程可以用已有的闲置线程来执行新任务，避免了线程创建和销毁带来的系统开销。
2.线程并发数量过多，抢占系统资源从而导致阻塞
线程能共享系统资源，如果同时执行的线程过多，就有可能导致系统资源不足而产生阻塞的情况
运用线程池能有效的控制线程最大并发数，可以解决上面的问题
3.对线程进行简单的管理
比如：延时执行，定时循环执行的策略，运用线程池都能进行很好的实现

线程池ThreadPoolExecutor

Java中，线程池的概念是Executor接口，ThreadPoolExecutor类是线程池中最核心的一个类，学习Java中的线程池，就可以直接学习这个类了。
对线程池的配置，就是对ThreadPoolExecutor构造函数的配置。
**ThreadPoolExecutor提供四个构造函数**

五个参数的构造函数 
public ThreadPoolExecutor(
    int corePoolSize, 
    int maximumPoolSize, 
    long keepAliveTime,
    TimeUnit unit, 
    BlockingQueue<Runnable> workQueue) 
六个参数的构造函数-1 
public ThreadPoolExecutor(
    int corePoolSize, 
    int maximumPoolSize,
    long keepAliveTime, 
    TimeUnit unit, 
    BlockingQueue<Runnable> workQueue, 
    ThreadFactory threadFactory)
六个参数的构造函数-2 
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)

参数一共有7种类型

- 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对象
当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务
常用的workQueue类型：
1.SynchronousQueue：这个队列接收到任务时，会直接提交给线程处理，而不保留它，如果所有的线程都在工作怎么办？那就新建一个线程来处理这个任务，所以为了保证不出现线程数达到了maximumPoolSize而不能新建线程的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
2.LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程（核心线程）处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
3.ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程（核心线程）去执行任务，如果达到了，则入队等候，如果队列已满，则新建线程（非核心线程）执行任务，又如果总数达到了maximumPoolSize，并且队列也满了，则发生错误。
4.DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

ThreadFactory threadFactory
线程工厂，主要用来创建线程的，这是一个接口，需要实现他的Thread newThread(Runnable r)方法
RejectedExecutionHandler handler
用来抛出异常，比如上面提到的两个错误发生了就会由handler抛出异常
**

向ThreadPoolExecutor添加任务

**
如何向线程池提交一个要执行的任务？
通过ThreadPoolExecutor.execute(Runnable command)方法即可向线程池内添加一个任务

ThreadPoolExecutor的策略

当一个任务被添加进线程池时：

线程数量未达到corePoolSize，则新建一个线程（核心线程）执行任务
线程数量达到了corePoolSize，则将任务移入队列等待
队列已满，新建线程（非核心线程）执行任务
队列已满，总线程数又达到了maximumPoolSize，就会由RejectedExecutionHandle抛出异常

常见四种线程池

Java通过Executors提供了四种线程池，这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的
CachedThreadPool() 可缓冲线程池
1.线程数无限制
2.有空闲线程则复用空闲线程，若无空闲线程则新建线程
3.一定程度上减少频繁创建/销毁线程，减少系统开销
创建方法：
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

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

FixedThreadPool() 定长线程池
1.可控制线程最大并发数（同时执行的线程数）
2.超出的线程会在队列中等待
支持定时及周期性任务执行
创建方法：

//nThreads => 最大线程数即maximumPoolSize ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads); //threadFactory => 创建线程的方法 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

源码：

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

ScheduledThreadPool() 定时线程池
创建方法：

//nThreads => 最大线程数即maximumPoolSize
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

源码：

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

SingleThreadExecutor() 单线程化线程池
1，有且只有一个工作线程执行任务
2.所有任务按照指定顺序执行，即遵循队列的入队出队规则
创建方法：

ExecutorService singleThreadPool = Executors.newSingleThreadPool();

源码：

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

如何合理配置线程池的大小

一般需要根据任务的类型来配置线程池大小：

如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1

如果是IO密集型任务，参考值可以设置为2*NCPU

在ThreadPoolExecutor类中有几个非常重要的方法：

execute()
submit()
shutdown()
shutdownNow()

execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。

submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果

shutdown()和shutdownNow()是用来关闭线程池的。

当创建线程池后，初始时，线程池处于RUNNING状态；

如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；

如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；

当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

实践

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,10,200,
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(5));
                for(int i = 0; i < 15; i++) {
                    MyTask task = new MyTask(i);
                    executor.execute(task);
                    System.out.println("线程池中线程数目：" + executor.getPoolSize()+
                            "队列中等待的任务数目：" + executor.getQueue().size() +
                            "已经执行完的任务数目：" + executor.getCompletedTaskCount()
                            );
                }
                executor.shutdown();
    }

}

class MyTask implements Runnable {
    private int taskNum;
    public MyTask(int num) {
        this.taskNum = num;
    }
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        System.out.println("正在执行task" + taskNum);
        try{
        Thread.currentThread().sleep(4000);
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task"+taskNum+"执行完毕");
    }

}

结果：

线程池中线程数目：1队列中等待的任务数目：0已经执行完的任务数目：0
线程池中线程数目：2队列中等待的任务数目：0已经执行完的任务数目：0
线程池中线程数目：3队列中等待的任务数目：0已经执行完的任务数目：0
线程池中线程数目：4队列中等待的任务数目：0已经执行完的任务数目：0
线程池中线程数目：5队列中等待的任务数目：0已经执行完的任务数目：0
线程池中线程数目：5队列中等待的任务数目：1已经执行完的任务数目：0
线程池中线程数目：5队列中等待的任务数目：2已经执行完的任务数目：0
线程池中线程数目：5队列中等待的任务数目：3已经执行完的任务数目：0
线程池中线程数目：5队列中等待的任务数目：4已经执行完的任务数目：0
线程池中线程数目：5队列中等待的任务数目：5已经执行完的任务数目：0
线程池中线程数目：6队列中等待的任务数目：5已经执行完的任务数目：0
线程池中线程数目：7队列中等待的任务数目：5已经执行完的任务数目：0
线程池中线程数目：8队列中等待的任务数目：5已经执行完的任务数目：0
线程池中线程数目：9队列中等待的任务数目：5已经执行完的任务数目：0
线程池中线程数目：10队列中等待的任务数目：5已经执行完的任务数目：0
正在执行task1
正在执行task10
正在执行task14
正在执行task3
正在执行task12
正在执行task2
正在执行task11
正在执行task0
正在执行task4
正在执行task13
task10执行完毕
task1执行完毕
正在执行task5
正在执行task6
task2执行完毕
task14执行完毕
task3执行完毕
task12执行完毕
正在执行task9
正在执行task8
正在执行task7
task11执行完毕
task0执行完毕
task4执行完毕
task13执行完毕
task5执行完毕
task6执行完毕
task9执行完毕
task7执行完毕
task8执行完毕

哪里都有好故事

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java并发编程：线程池的原理

为什么我们要用线程池？1.如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。假如创建一个线程消耗时间为T1，执行任务消耗时间T2，销毁线程消耗时间T3。如果T1+T3 &gt; T2，线程用来创建和销毁的时间大于了执行任务的...
复制链接

扫一扫

专栏目录