Java语法进阶及常用技术(八)--线程池

初识线程池

什么是“池”
---- 软件中的“池”,可以理解为计划经济。
我们的资源是有限的,比如只有十个线程,我们创造十个线程的线程池,可能我们的任务非常多,如1000个任务,我们就把1000个任务放到我们十个线程中去,慢慢的去执行,最终会执行完所有任务。但是资源总量十个线程是被控制住的,还有就是不需要再创建更多的线程了,创建线程是有一定的开销的。所以我们复用线程池的这十个线程,每个线程的执行效率也会提高。

如果不适用线程池,每个任务都新开一个线程处理

  • 一个线程
  • for循环创建线程
  • 当任务数量上升到1000

这样开销太大,我们希望有固定数量的线程,来执行这1000个任务,这样就避免了反复创建并销毁线程所带来的开销问题。

为什么要使用线程池

  • 问题一:反复创建线程开销大
  • 问题二:过多的线程会占用太多内存
  • 解决以上两个问题的思路:
    • 用少量的线程 ----避免内存占用过多
    • 让这部分线程都保持工作,且可以反复执行任务 ---- 避免生命周期的损耗。

线程池的好处

  • 加快响应速度
  • 合理利用CPU和内存
  • 统一管理

线程池适合应用的场合

  • 服务器接收到大量请求时,使用线程池技术是非常合适的,它可以大大减少线程的创建和销毁次数,提高服务器的工作效率。
  • 实际上,在开发中,如果需要创建5个以上的线程,那么就可以使用线程池来管理。

创建和停止线程池

线程池构造方法的参数
Java语法进阶及常用技术(八)--线程池_第1张图片

  • corePoolSize指的是核心线程数
    -线程池在完成初始化后,默认情况下,线程池中并没有任何线程,线程池会等待有任务到来时,再创建新线程去执行任务。
  • 最大量maxPoolSize
    -在核心线程数的基础上,额外增加的线程数的上限。
    Java语法进阶及常用技术(八)--线程池_第2张图片
    添加线程规则
  • 如果线程数小于corePoolSize,创建一个新线程来运行新任务。
  • 如果线程数等于(或大于)corePoolSize但少于workQueue上限,则将任务放入队列。
  • 如果队列已满,并且线程数小于maxPoolSize,则创建一个新线程。
  • 如果队列已满,并且线程数大于或等于maxPoolSize,则拒绝。
    Java语法进阶及常用技术(八)--线程池_第3张图片
    增减线程的特点
  • 通过设置corePoolSize和maximumPoolSize相同,就可以创建固定大小的线程池。
  • 线程池希望保持较少的线程数,并且只有在负载变得很大时才增加它。
  • 通过设置maximumPoolSize为很高的值,可以允许线程池容纳任意数量的并发任务。
  • 只有在队列填满时才创建多于corePoolSize的线程,如果使用的是无界队列,那么线程数就不会超过corePoolSize。

keepAliveTime
如果线程池当前的线程数多于corePoolSize,那么如果多余的线程空闲时间超过keepAliveTime,它们就会被终止。

ThreadFactory用来创建线程

  • 默认使用Executors.defaultThreadFactory()
  • 创建出来的线程都在同一个线程组
  • 如果自己指定ThreadFactory,那么就可以改变线程名、线程组、优先级、是否是守护线程等。

工作队列
有3种最常见的队列类型:

  • 直接交换:SynchronousQueue
  • 无界队列:LinkedBlockingQueue
  • 有界的队列:ArrayBlockingQueue

线程池该手动创建还是自动创建

手动创建更好,因为这样可以更加明确线程池的运行规则,避免资源耗尽的风险。
自动创建线程池(即直接调用JDK封装好的构造方法)可能带来哪些问题?
FixedThreadPool
源码为

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

可看出corePoolSize和maximumPoolSize相同,且keepAliveTime为0,工作队列为LinkedBlockingQueue无界队列。
容易造成大量内存占用,可能会导致OOM。
Java语法进阶及常用技术(八)--线程池_第4张图片

SingleThreadExecutor
源码为

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

可看出corePoolSize和maximumPoolSize相同且为1,且keepAliveTime为0,工作队列为LinkedBlockingQueue无界队列。
当请求堆积的时候,可能会占用大量的内存。

CachedThreadPool
可缓存线程池
特点:具有自动回收多余线程的功能
Java语法进阶及常用技术(八)--线程池_第5张图片
源码为

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

弊端在于第二个参数maximumPoolSize被设置为了Integer.MAX_VALUE,这可能会创建数量非常多的线程,甚至导致OOM

ScheduledThreadPool
支持定时及周期性任务执行的线程池
Java语法进阶及常用技术(八)--线程池_第6张图片
以上4种线程池的构造方法的参数
Java语法进阶及常用技术(八)--线程池_第7张图片

正确的创建线程池的方法

  • 根据不同的业务场景,设置线程池参数。
  • 比如:内存有多大,给线程取什么名字等等

线程池里的线程数量设定为多少比较合适?

  • CPU密级型(加密、计算hash等):最佳线程数为CPU核心数的1-2倍左右。
  • 耗时IO型(读写数据库、文件、网络读写等):最佳线程数一般会大于CPU核心数很多倍。

参考Brain Goetz推荐的计算方法:
在这里插入图片描述
workStealingPool是JDK1.8加入的
子任务:比如二叉树的遍历
窃取:子任务会被放到每个线程独有的任务队列,而不是公共队列。比如有个线程产生了很多子任务,其他线程如果是空闲,会帮助第一个线程,窃取它的子任务去执行。这个任务最好不能加锁,也不能保证执行顺序。

停止线程池的正确方法

  • shutdown :运行了这个方法,线程池有新的任务会拒绝并抛出拒绝的异常,会把正在执行的任务和队列里等待的任务都执行完毕后关闭线程池。
  • isShutdown:返回线程池是否有停止标记(是否执行过shutdown)
  • isTerminated:返回线程池是否完全终止
  • awaitTermination:等待一段时间检测线程是否终止
  • shutdownNow:立刻关闭线程池,并返回未执行的任务列表。

暂停和恢复线程池

任务太多,怎么拒绝?

  • 拒绝时机
    • 当Executor关闭是,提交新任务会被拒绝。
    • 以及当Executor对最大线程和工作队列容量使用有限边界并且已经饱和时。

4种拒绝策略

  • AbortPolicy 直接抛出异常
  • DiscardPolicy 默默地把任务丢弃,不会通知
  • DiscardOldestPolicy 丢弃最老的任务
  • CallerRunsPolicy 谁提交的任务,让谁执行

钩子方法
给线程池加点料
每个任务执行前后、日志、统计等场景使用

package com.ql;

import java.util.concurrent.*;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 演示每个任务执行前后放钩子函数
 */
public class PauseableThreadPool extends ThreadPoolExecutor {
    private boolean isPaused;
    private final ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    /**
     * 默认重写,不用管
     */
    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    /**
     * 默认重写,不用管
     */
    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    /**
     * 默认重写,不用管
     */
    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    /**
     * 默认重写,不用管
     */
    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    /**
	 * 重写该方法,在任务执行前放钩子函数
     */
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        lock.lock();
        try {
            while (isPaused){
                condition.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
	
    private void pause(){
        lock.lock();
        try{
            isPaused = true;
        }finally {
            lock.unlock();
        }
    }

    public void resume(){
        lock.lock();
        try{
            isPaused = false;
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        PauseableThreadPool pauseableThreadPool = new PauseableThreadPool(10, 20, 10l, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我被执行");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 200; i++) {
            pauseableThreadPool.execute(runnable);
        }
        Thread.sleep(1500);
        pauseableThreadPool.pause();
        System.out.println("线程池被暂停了~~");
        Thread.sleep(1500);
        pauseableThreadPool.resume();
        System.out.println("线程池被恢复了~~");
    }
}
/**执行结果
...
我被执行
我被执行
我被执行
我被执行
线程池被暂停了~~
线程池被恢复了~~
我被执行
我被执行
我被执行
我被执行
...
*/

线程池实现原理

线程池组成部分

  • 线程池管理器:创建停止线程池等
  • 工作线程:创建出来执行任务的线程
  • 任务队列:存放未执行任务的队列,必须支持并发
  • 任务接口(Task)

Java语法进阶及常用技术(八)--线程池_第8张图片
线程池相关类和接口关系
Java语法进阶及常用技术(八)--线程池_第9张图片
Executors是Java提供的工具类,包含了很多自带的线程池。
线程池实现任务复用的原理

  • 相同线程执行不同任务

线程池状态

Java语法进阶及常用技术(八)--线程池_第10张图片
使用线程池的注意点

  • 避免任务堆积
  • 避免线程数过度增加
  • 排查线程泄漏

你可能感兴趣的:(java,多线程,线程池)