线程池的机制

主机优惠 • • 杂文
老生常谈的问题：什么是线程池？

线程池就是创建若干个可执行的线程放入一个池（容器）中，有任务需要处理时，会提交到线程池中的任务队列，处理完之后线程并不会被销毁，而是仍然在线程池中等待下一个任务。

为什么要用线程池？

1.创建/销毁线程伴随着系统开销，使用多线程过于频繁的创建/销毁线程，会很大程度上影响处理效率；这里线程池可以复用线程，线程池可以避免性能降低。
2.线程并发数量过多，抢占系统资源从而导致阻塞；这里线程池可以显示最大线程数量。
3.对线程进行一些简单的管理

讲线程池原理之前，先讲一讲线程池原理要涉及到的阻塞队列。

阻塞队列：

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这里会有两个阻塞动作：在队列为空时，获取元素的线程会阻塞来等待队列变为非空。当队列满时，存储元素的线程会阻塞来等待队列可用。

JDK提供了一个阻塞队列的接口类BlockingQueue：
插入移除有三对方法，既有阻塞方法，也有非阻塞方法。

add(e)与remove() ，如果遇到阻塞，会抛出异常
offer(e)与poll()，如果遇到阻塞，offer返回false，poll返回null
put(e)与take() ，如果遇到阻塞，会一直阻塞

阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

7个阻塞队列：

ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列，可以对元素类实现comparator，依据此进行排序。
DelayQueue：一个支持延时获取元素的无界阻塞队列，如果一个元素的延迟时间没有到，元素是获取不到的。
SynchronousQueue：一个不存储元素的阻塞队列。

有界表示队列长度有限，无界表示长度无限，可以无限放入元素。这个容量会在构造方法传入capacity值来初始化最大容量。

源码分析：

这里是ThreadPoolExecutor的构造方法：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue 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;
    }
参数意义：

int corePoolSize, 核心线程数
int maximumPoolSize, 最大线程数
long keepAliveTime, 设置空闲线程的存活时间
TimeUnit unit, 设置空闲线程的存活时间单位
BlockingQueue workQueue, 保存任务的阻塞队列
ThreadFactory threadFactory, 创建线程的工厂，给新建的线程赋予名字
RejectedExecutionHandler handler) 饱和/拒绝策略,内置4种策略

拒绝策略：
  • AbortPolicy ：直接抛出异常，默认；
  • CallerRunsPolicy：用调用者所在的线程来执行任务
  • DiscardOldestPolicy：丢弃阻塞队列里最老的任务，队列里最靠前的任务
  • DiscardPolicy ：当前任务直接丢弃
线程池工作机制图：
线程池运行机制：

当程序生产了任务之后，提交进线程池。线程池会创建出corePoolSize数量的线程执行任务。如果任务数超出了corePoolSize，那么阻塞队列派上用场了，会将任务放入到阻塞队列中。如果任务数继续增大，阻塞队列也满了，这个时候才会继续新起线程执行任务。而如果线程总数达到了maximumPoolSize，那么这个时候饱和策略就会执行了。

ExecutorService类结构：

submit:向线程池提交任务
shutdown:尝试关闭线程池，将当前没有执行任务的线程中断
shutdownNow:将当前线程所有线程立即进行中断

线程池提交任务的方式

1.excute(runnable)方法提交，提交的任务不管返回结果
2.submit(runnable,callback)方法提交，提交的任务可以得到任务执行完成的返回结果。

线程池如何配置合理线程数

（1）CPU密集型：
定义：CPU密集型的意思就是该任务需要大量运算，而没有阻塞，CPU一直全速运行。
CPU密集型任务配置尽可能少的线程数，因为线程上下文切换会耗费更多的时间。
配置线程数：CPU核数+1

（2）IO密集型：
定义：IO密集型，即该任务需要大量的IO，即大量的阻塞。
在单线程上运行IO密集型任务会导致浪费大量的CPU运算能力浪费在等待。
所以IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要利用了被浪费掉的阻塞时间。
配置线程数：CPU核数 * 2

CPU核心数获取方法：

 Runtime.getRuntime().availableProcessors()

各种线程池的创建方式：

1.创建缓存线程池：

        //创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

内部实现方式：

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

2.创建单线程池：

 //创建一个线程的线程池，保证任务执行顺序和添加任务顺序一致
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

内部实现方式：

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

3.创建定长线程池

//创建定长线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

内部实现方式：

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

4.创建周期线程池

 //创建一个定长线程池，定时及周期性任务执行
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);

内部实现方式：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
使用线程池执行任务：
        threadPool.execute(new Runnable() {
            @Override
            public void run() {

            }
        });
使用线程池关闭任务：

原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程

        cachedThreadPool.shutdown();

        cachedThreadPool.shutdownNow();

验证各种线程池特性：

创建执行的任务：任务就是打印各自的"类路径+@+hashcode"。

    public static class MyRunable implements Runnable {

        public MyRunable(){

        }

        @Override
        public void run() {
            System.out.println("开始处理任务");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("当前执行任务线程" + this.toString());
        }
    }

1.循环创建任务放入CachedThreadPool中执行：

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for(int i=0;i<10;i++){
            cachedThreadPool.execute(new MyRunable());
        }

打印结果：给多少个任务，就创建多少个线程，缓存线程池不限制线程大小

开始处理任务
开始处理任务
开始处理任务
开始处理任务
开始处理任务
开始处理任务
开始处理任务
开始处理任务
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@4ee88e47
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@51dbc572
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@6350da9f
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@34258bc7
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@2dd943ad
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@786a52e0
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@b89fbe7
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@834fe66
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@52922937
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@3d339f20

2.循环创建任务放入SingleThreadPool中执行：

        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

        for(int i=0;i<10;i++){
            singleThreadPool.execute(new MyRunable());
        }

当前只有一个线程处理任务，任务按照加入顺序依序执行：

开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@35b893c9
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@3b7f6b0e
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@3f40f8b9
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@7a426135
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@b95836f
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@4bf2be08
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@73cf02ff
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@1a6d9e7a
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@3d44e8a3
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@639803fd

3.循环创建任务放入FixedThreadPool中执行：
定长线程池，设置最大线程数为3；

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for(int i=0;i<10;i++){
            fixedThreadPool.execute(new MyRunable());
        }

最多能有3个线程同时处理任务：

开始处理任务
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@f1c2027
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@464fea81
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@72e3cfe6
开始处理任务
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@48881c38
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@7c242fca
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@1dbcfb4
开始处理任务
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@4cb781f1
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@5e44b57
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@781ba496
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@9b51603

4.循环创建任务放入ScheduledThreadPool中执行：

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for(int i=0;i<10;i++){
            scheduledExecutorService.schedule(new MyRunable(),4, TimeUnit.SECONDS);
        }

也是需要固定线程大小，不过比fixed多了延迟执行。

开始处理任务
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@2fec69f9
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@1188fc84
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@7b1e0a3d
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@1f4f00c5
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@75d9fb2e
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@2bd3e8dc
开始处理任务
开始处理任务
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@71e6614d
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@1b7097f4
开始处理任务
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@6ed163c2
当前执行任务线程com.example.apple.threadpooluse.MainActivity$MyRunable@34e4f115
这么多种线程池，如何合理地配置线程池？

根据任务特性：

  • CPU密集型：
    （1）高并发、任务执行时间短的业务，如纯粹的计算，线程池线程数可以设置为CPU核数+1，不能再多了，能减少线程上下文的切换
Runtime.getRuntime().availableProcessors()   //获取CPU核心数
  • IO密集型：
    并发不高、任务执行时间长的业务，如IO操作，网络请求，线程容易停下来，不要让所有的CPU闲下来，可以适当加大线程池中的线程数目，让CPU处理更多的业务
    推荐配置线程数不要超过整体的CPU核心数的2倍。

版权声明：
作者：主机优惠
链接：https://www.techfm.club/p/45525.html
来源：TechFM
文章版权归作者所有，未经允许请勿转载。

THE END
分享
二维码
< <上一篇
下一篇>>