Java 由浅入深聊聊线程池及原理

其他 2020-04-03 11:55:34 阅读次数: 0

线程池的优势

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务加入队列，然后在线程创建后启动这些任务，如果线程超过了最
大数量，超出的数量的线程排队等候等其他线程执行完毕再从队列中取出任务来执行。

他的主要特点为：线程复用；控制最大并发数；管理线程。

第一：降低资源消耗。通过重复利用自己创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时,任务可以不需要等到线程和粗昂就爱你就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限的创阿金，不仅会消耗资源，还会较低系统的稳定性，使用线程池可以进行统一分配，调优和监控。

架构图

Java中的线程池是通过Executor框架实现的

种类及使用

Java 线程池总共分为五种

1.newFixedThreadPool

创建一个定长线程池，可控制线程的最大并发数，超出的线程会在队列中等待。在某个线程被显式地关闭之前，池中的线程将一直存在。

newFixedThreadPool 创建的线程池 corePoolSize 和 MaxmumPoolSize 是相等的，阻塞队列使用的的LinkedBlockingQueue

示例

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

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        try {
            for (int i = 1; i < 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();//关闭线程池
        }
    }
}

结果

2.newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务都按照指定顺序执行。

newSingleThreadExecutor 将corePoolSize 和MaxmumPoolSize 设置为1，阻塞队列使用的的LinkedBlockingQueue

示例

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

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        try {
            for (int i = 1; i < 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();//关闭线程池
        }
    }
}

结果

3.newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则创建新线程。

newCachedThreadPool 将 corePoolSize 设置为 0，MaxmumPoolSize 设置为 Integer.MAX_VALUE，阻塞队列使用的是SynchronousQueue，也就是说来了任务就创建线程运行，如果线程空闲超过60秒，就销毁线程。

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

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        try {
            for (int i = 1; i < 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();//关闭线程池
        }
    }
}

结果

4.newScheduleThreadPool

创建一个带调度的线程池，支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

示例

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService threadScheduledPool = Executors.newScheduledThreadPool(5);
        try {
            threadScheduledPool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("延迟1S后执行");
                }
            },1, TimeUnit.SECONDS);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadScheduledPool.shutdown();//关闭线程池
        }
    }
}

结果

源码分析

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

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

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

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

}

通过观察源码，我们可以发现四种线程池的创建都依赖了一个 ThreadPoolExecutor 类。打开 ThreadPoolExecutor ，发现他们调用的都是七个参数的构造方法。

七大参数分析

1.corepoolsize

线程池中的常驻核心线程数。线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。

2.maximumPoolsize

线程池能够容纳同时执行的最大线程数，此值大于等于1。一个任务被提交到线程池后，首先会缓存到工作队列中，如果工作队列满了，则会创建一个新线程，然后从工作队列中的取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由 maximunPoolSize 来指定。

3.keepAliveTime

一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定

4.unit

keepAliveTime的单位

5.workQueue

任务队列，被提交但尚未被执行的任务。新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。

jdk中提供了四种工作队列：

  1. ArrayBlockingQueue
  2. LinkedBlockingQuene
  3. SynchronousQuene
  4. PriorityBlockingQueue

如果不了解阻塞队列，可以看看这篇博客 谈谈阻塞队列

6.threadFactory

表示生成线程池中工作线程的线程工厂，用户创建新线程，一般用默认即可

7.handler

拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大显示数(maxnumPoolSize)时如何来拒绝

底层原理

主要四步操作流程：

  1. 在创建了线程池后，等待提交过来的任务请求。
  2. 当调用execute() 方法添加一一个请求任务时，线程池会做如下判断：
    1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
    2. 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
    3. 如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
    4. 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
  3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。
  4. 当一个线程无事可做超过一定的时间(keepAliveTime) 时，线程池会判断:如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。

拒绝策略

jdk中提供了4中拒绝策略：

  1. CallerRunsPolicy：该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。
  2. AbortPolicy：该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。
  3. DiscardPolicy：该策略下，直接丢弃任务，什么都不做。
  4. DiscardOldestPolicy：该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列，这是最好的拒绝策略

手写线程池

虽然JDK给我们提供了线程池，但是我们在实际生产过程中是不能直接使用的，阿里巴巴手册已经规定。

原因很简单，因为他们底层用的都是 LinkedBlockingQueue ，而他是一个“无界”阻塞队列，他的界限太大了，会导致 OutOfMenery异常。

示例1(使用AbortPolicy策略)

import java.util.concurrent.*;

public class ThreadPool {
    public static void main(String[] args) {
        int corePoolSize = 2;   //核心线程数2
        int maximumPoolSize = 5;    //最大线程数5
        long keepAliveTime = 1L;    //空闲时间1s
        TimeUnit unit = TimeUnit.SECONDS;   //单位 秒
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(3);   //阻塞队列，最大3
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); //线程工厂，使用默认
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();    //拒绝策略，抛异常
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);

        try {
            for (int i = 0; i < 9 ; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

结果

当我们把生成线程数由8改为9的时候，就会发现抛 RejectedExecutionException 异常了，所以当前最大可连接数量 <= maximumPoolSize + 队列最大长度，一旦连接数量超过就抛异常

示例2(使用CallerRunsPolicy策略)

import java.util.concurrent.*;

public class ThreadPool {
    public static void main(String[] args) {
        int corePoolSize = 2;   //核心线程数2
        int maximumPoolSize = 5;    //最大线程数5
        long keepAliveTime = 1L;    //空闲时间1s
        TimeUnit unit = TimeUnit.SECONDS;   //单位 秒
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(3);   //阻塞队列，最大3
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); //线程工厂，使用默认
        RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();    //调用者模式，回退调用者
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
        try {
            for (int i = 0; i < 9 ; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

结果

运行结果里面多了一个 main 线程，这是因为超过最大值以后回退调用线程进行执行了。

示例3(使用DiscardOldestPolicy策略)

import java.util.concurrent.*;

public class ThreadPool {
    public static void main(String[] args) {
        int corePoolSize = 2;   //核心线程数2
        int maximumPoolSize = 5;    //最大线程数5
        long keepAliveTime = 1L;    //空闲时间1s
        TimeUnit unit = TimeUnit.SECONDS;   //单位 秒
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(3);   //阻塞队列，最大3
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); //线程工厂，使用默认
        RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardOldestPolicy(); 
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
        try {
            for (int i = 0; i < 10 ; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

结果

有10个线程访问，但是最终只输出了8行。在这种策略下，他会抛弃进入队列最早的那个任务，然后加入最新的。

示例4(使用DiscardPolicy策略)

import java.util.concurrent.*;

public class ThreadPool {
    public static void main(String[] args) {
        int corePoolSize = 2;   //核心线程数2
        int maximumPoolSize = 5;    //最大线程数5
        long keepAliveTime = 1L;    //空闲时间1s
        TimeUnit unit = TimeUnit.SECONDS;   //单位 秒
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(3);   //阻塞队列，最大3
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); //线程工厂，使用默认
        RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
        try {
            for (int i = 0; i < 10 ; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+" invoked");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

结果

有10个线程访问，但是最终只输出了8行。虽然和 DiscardOldestPolicy 结果类似，但是还是这种策略把最新的请求都拒绝了。

线程池参数合理配置

CPU密集型

插播：Java获取线程数

// 获取线程数
System.out.println(Runtime.getRuntime().availableProcessors());

CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)

CPU密集型任务配置尽可能少的线程数量：
一般公式：CPU核数+1个线程的线程池

IO密集型

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

参考1

IO密集型时，大部分线程都阻塞，故需要多配置线程数：
参考公式：CPU核数/(1- 阻塞系数)【阻塞系数在0.8~0.9之间】
比如8核CPU：8/(1-0.9) = 80个线程数

参考2

由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如CPU核数*2

楚瑞涛
发布了80 篇原创文章 · 获赞 55 · 访问量 2万+
私信 关注

猜你喜欢

转载自blog.csdn.net/cong____cong/article/details/104763462
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022