01-JUC--ThreadPool

原创 于 2021-02-16 12:19:59 发布 · 798 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程

本文详细介绍了ThreadPool的重要性，创建线程池的参数设定，Executors提供的线程池类型（如FixedThreadPool、SingleThreadPool等），线程数量选择、线程池控制与拒绝策略。阅读本文，了解如何优化线程池使用以提升性能和避免问题。

ThreadPool

线程池简介

这篇文章写的好。放个连接，是一个非常好的阅读材料。

美团技术团队：https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。

线程池的重要性

如果不使用线程池，每个任务都新开一个线程处理。
1.一个线程
2.for循环创建线程
3.1000个线程 这种方式开销太大，我们希望有固定数量的线程，来执行这个1000个任务，这样 就避免了反复创建并销毁线程所带来的开销问题。

为什么使用线程池？

1.反复创建线程开销大 2.过多的线程占用太多内存

解决方法： 1.用少量的线程–减少内存占用 2.让这部分线程始终保持工作状态，且可以反复执行任务—避免生命周期的损耗

线程池的好处： 1.加快响应速度 2.合理利用CPU和内存 3.统一管理资源

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

创建线程池

线程池构造函数的参数

在这里插入图片描述

corePoolSize

corePoolSize是核心线程数：线程池在完成初始化后，默认情况下，线程池中并没有任何线程，线程池会等待有任务到来时，再创建新线程去执行任务

maxPoolSize

线程池有可能会在核心线程数的基础上，再额外添加一些线程，只有在线程数小于maxPoolSize时才能在corePoolSize基础上新增线程。

在这里插入图片描述

keepAliveTime

如果currentThread > corePoolSize，那么超出corePoolSize部分的线程，只能存活keepAliveTime，超过这个时间就会被回收。

ThreadFactory

新的线程是由ThreadFactory创建的，默认使用Executors.defaultThreadFactory()，创建出来的线程都在同一个线程组，拥有同样的NORM_PRIORITY优先级并且都不是守护线程。如果自己指定ThreadFactory，那么久可以改变线程名、线程组、优先级、是否是守护线程等。

workQueue

常见的3中队列类型：

  1. 直接交换：SynchronousQueue ---- 队列不会作缓冲，内部没有容量；只作为一个中转站，如果使用这种队列，maxPoolSize要设置大一些，因为比较容易新增线程。

  2. 无界队列： LinkedBlockingQueue – 顾明思议，没有边界的队列，容量非常大。使用这种队列，会使maxPoolSize失去意义。

  3. 有界队列： ArrayBlockingQueue — 有界队列，可以设定队列的大小。这个是比较常用的。

添加线程的规则

在这里插入图片描述

1.如果currentThread < corePoolSzie,即使其他工作线程处于空闲状态，也会创建一个新线程来运行新任务。
2. 如果currentThread >= corePoolSize && currentThread < maxPoolSize，则将任务放入queue。
3. 如果queue已满，并且currentThread < maxPoolSize， 则创建一个新线程来运行任务。
4. 如果queue满，currentThread达到最大线程数，则执行拒绝执行策略。

判断顺序： corePoolSize，workQueue，maxPoolSize

可以利用这几个核心参数，创建一些具有特定属性的线程池：

  1. 通过设置corePoolSize == maxPoolSize，得到一个固定大小的线程池，相当于Executors.newFixedThreadPool(参数（期望得到线程池的大小）)
  2. 通过设置maxPoolSzie为很高的值，例如Integer.MAX_VALUE，得到一个允许容纳任意数量并发任务的线程池。

来自美图：常见队列类型来自美团：JDK提供的四种拒绝策略

Executors提供的几种线程池

newFixedThreadPool
/*
此demo会不断输出4个线程的名字；
*/
public class FixedThreadPoolDemo {

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 1000; i++) {
            service.submit(new Task());
        }
    }
}
class Task implements  Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
源码分析

通过下面两张图片，我们可以知道newFixedThreadPool也是调用原生JDK给我们提供的ThreadPoolExecutor，只是帮我们封装好了一些参数。这里它是把corePoolSize和maxPoolSize设置成相同，就得到一个固定大小的线程池，而且使用的是LinkedBlockingQueue（无界队列）
在这里插入图片描述
在这里插入图片描述

下面演示 newFixedThreadPool可能会出现的错误：
使用的是LinkedBlockingQueue队列，如果大量任务堆积在queue中，就有可能会出现OutOfMemoryError


/**
 * @Classname FIxedThreadPoolOOMDemo
 * @Description 演示 newFiexedThreadPool 溢出错误 OutOfMemoryError
 * @Date 2021/2/16 12:46
 * @Created by YoungLiu
 */
public class FIxedThreadPoolOOMDemo {
    private static ExecutorService service =
            Executors.newFixedThreadPool(1);

    public static void main(String[] args) {
        for(int i=0;i<Integer.MAX_VALUE;++i){
            service.execute(new SubThread());
        }
    }
    private static class SubThread implements Runnable{

        @Override
        public void run() {
            try {
                Thread.sleep(1000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
newSingleThreadPool

顾名思义，只有一个线程的线程池。

/**
 * @Classname SingleThreadExecutor
 * @Description TODO
 * @Date 2021/2/16 12:52
 * @Created by YoungLiu
 */
public class SingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 1000; i > 0; i--) {
            service.execute(new Task());
        }
    }
}
源码分析

通过corePoolSize== maximumPooSzie =1，得到一个线程数量为1的固定大小的线程池。
在这里插入图片描述

CacheThreadPool

可缓存的线程池，具有自动回收多余线程的功能
在这里插入图片描述


/**
 * @Classname CacheThreadPool
 * @Description TODO
 * @Date 2021/2/16 13:01
 * @Created by YoungLiu
 */
public class CacheThreadPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            service.execute(new Task());
        }
    }
}
源码分析

可以看到corePoolSize为0，而maximumPoolSize很大，这有可能会导致创建数量非常多的线程，甚至会导致OOM；空闲的线程超过60秒后，就会被回收。
在这里插入图片描述

ScheduledThreadPool

支持定时及周期性任务执行的线程池

/**
 * @Classname ScheduledThreadPoolDemo
 * @Description 演示ScheduledThreadPool的常见用法
 * @Date 2021/2/16 13:05
 * @Created by YoungLiu
 */
public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(10);
        //5秒后执行任务
        scheduledThreadPool.schedule(new Task(),5, TimeUnit.SECONDS);
        //间隔执行任务，一开始1秒执行，然后每隔3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Task(),1,3,TimeUnit.SECONDS);
    }
}
源码分析

在这里插入图片描述

在这里插入图片描述
图2的super指向ThreadPoolExecutor
在这里插入图片描述

分析了上面几种的常见自动化创建线程池，发现都有一些弊端；在实际业务中，我们最好自己手动使用ThreadPoolExecutor来创建线程池。

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

在这里插入图片描述

以上四种线程池的构造函数的参数

在这里插入图片描述

停止线程池的正确方法

  1. 使用shutdown – 将线程池置为stop状态；但已在队列的任务会继续执行，但拒绝接受新任务加入队列。
    在这里插入图片描述

  2. isShutDown – 检查线程池是否处于stop状态，返回一个boolean
    在这里插入图片描述

  3. isTerminated – 检查线程池是否完全处于停止状态；即所有队列都为空，且不再接收和执行任务；
    ![](https://img-blog.csdnimg.cn/20210216215624187.png)

  4. awaitTermination – 等待一段时间，在等待时间内，如果线程都执行完毕，返回true，否则false。

在这里插入图片描述

  1. shutdownnow – 立刻将线程池置为完全停止状态，返回一个被中断任务（已在阻塞队列中，但未执行的任务）的列表。

在这里插入图片描述

public class ShuntDown {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            service.execute(new ShutDownTask());
        }
        Thread.sleep(1500);
        //这里会将线程池置为stop状态，不太接受新任务；但会继续执行已在队列的任务
        service.shutdown();
        System.out.println(service.isShutdown());//false
        //这里会报错ava.util.concurrent.RejectedExecutionException；因为线程池不再接收新的任务
        service.execute(new ShutDownTask());
        System.out.println(service.isShutdown());//true

    }
}
class ShutDownTask implements  Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程池如何拒绝过多的任务？

在这里插入图片描述
在这里插入图片描述

线程池的拒绝策略
  1. AbortPolicy – 抛出拒绝异常
  2. DiscardPolicy – 默默地丢弃任务，不会通知用户
  3. DiscardOldestPolicy – 丢弃最老，存在时间最久的任务
  4. CallerRunsPolicy – 线程池决绝接收，但由提交任务的线程执行此任务

在这里插入图片描述

钩子方法

在每个任务执行前后，执行特定的动作。


/**
 * @Classname PauseableThreadPool
 * @Description 演示在每个任务的执行前后，放钩子
 * @Date 2021/2/16 22:16
 * @Created by YoungLiu
 */
public class PauseableThreadPool  extends ThreadPoolExecutor {

    private boolean isPaused;
    private final ReentrantLock lock = new ReentrantLock();
    private Condition unpaused = lock.newCondition();

    /**
     * 此方法在每个任务执行前执行特定的动作；相当于AOP的前置通知
     * @param t
     * @param r
     */
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        lock.lock();

            try {
                while(isPaused){
                 unpaused.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
    }

    private void pause(){
        lock.lock();
        try {
            isPaused =true;
        }finally {
            lock.unlock();
        }
    }
    private void resume(){
        lock.lock();
        try{
            isPaused=false;
            //唤醒所有线程
            unpaused.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(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for (int i = 0; i < 10000; i++) {
            pauseableThreadPool.execute(runnable);
        }
        Thread.sleep(1500);
        pauseableThreadPool.pause();
        System.out.println("线程池被暂停了");
        Thread.sleep(1500);
        System.out.println("线程池被恢复了");

    }



    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);
    }




}

线程池的继承链

在这里插入图片描述

线程池的状态

在这里插入图片描述

源码分析

在这里插入图片描述

使用线程池的注意点

  1. 避免任务堆积
  2. 避免线程数量的过度增加
  3. 排查线程泄露
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值