线程池

最新推荐文章于 2024-07-23 15:49:46 发布
最新推荐文章于 2024-07-23 15:49:46 发布
阅读量114 收藏
点赞数
分类专栏： 并发 文章标签： 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39827145/article/details/92830852
版权

一、线程池

下面这几组大家应该很属于，加 s 的都是工具类
Array Arrays
Collection Collections
Executor Executors

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//上面和下面是等价的
List<String> list = Arrays.asList("a","b","c");

在这里插入图片描述

1.获取线程池的方法

1.1三种获取线程池的方法（但是，这三种在生产中都不允许使用！！！）

1.一池固定数线程
2.一池一线程
3.一池多线程

        1. ExecutorService executorService1 = Executors.newFixedThreadPool(5);
        2. ExecutorService executorService2 = Executors.newSingleThreadExecutor();
        3. ExecutorService executorService3 = Executors.newCachedThreadPool();

底层源码如下：
在这里插入图片描述
在这里插入图片描述
所有线程池底层都是调这个构造方法实现的

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> 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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

下面给大家分享一下七大参数的详解

corePoolSize：线程池中常驻核心线程数（比如：银行网点，每天默认只开两个窗口给客服办理业务）

maximumPoolSize：线程池能够同时容纳最大的线程数，必须大于等于1（比如：银行网点，最多只有五个窗口给客户办理业务）

keepAliveTime：多余线程的存活时间（比如：银行网点，每天默认只开两个窗口给客服办理业务，今天中午人很多，又临时开了三个窗口给客户办理业务，下午人又少了，60分钟内，没有人办理业务，临时窗口就关闭，一般个unit参数一起使用，一个控制数字，一个控制单位，组合控制时间长短）

unit：keepAliveTime的单位（解释在上面）

workQueue：任务队列，被提交但尚未执行（比如：银行网点的候客区）

threadFactory：表示生成线程池中工作线程的工厂，一般默认即可（比如：银行网点的HR，负责找员工过来上班）

handler：拒绝策略，表示队列满了，并且工作线程数等于线程池最大线程数了。（比如：银行网点，候客区人满了，没有座位了，并且五个窗口都已经开了，此时银行保安就会拒绝其他客户来办理业务）

2.JDK内置的拒绝策略

AbortPolicy（默认）：直接抛出RejectedExecutionException异常，阻止系统正常执行
CallerRunsPolicy：“调用者运行”一种调用机制，该策略既不会抛出异常，也不会抛弃任务，而是将默些任务回退到调用者，从而降低新的任务流量
DiscardOldestPolicy：丢弃队列中等待最久的任务，然后把当前任务加入到队列中尝试重新提交任务
DiscardPolicy：直接丢任务，不抛任何异常。如果允许任务丢失，这是最好的策略。

3. 生产情况下，自己写线程池

先说说为什么我们不用内置的线程池
在这里插入图片描述
在这里插入图片描述
我们都知道创建线程需要一个阻塞队列，源码用的是LinkedBlockingQueue，我们又知道LinkedBlockingQueue是一个可以说是无界的队列，因为他的长度是Integer的最大值（2147483647），所有可以说他是一个无界的

3.1 手写线程池

下面我们开始写一个自己的线程池：

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.concurrent.*;

/**
 * 我的线程池
 *
 * @author yangjikang
 * @date 2019/6/19 10:39
 * @modified By yangjikang
 */
public class TestExecutor {

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        try {
            for (int i = 0; i < 8; i++) {
                final String tempUser = i + "号客户";
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 窗口给" + tempUser + "办理业务...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

控制台效果图
在这里插入图片描述
上面，这段代码，我们是模拟8个客户来银行办理业务的场景。没有异常，属于正常情况

3.2 AbortPolicy拒绝策略

继续看下面的代码：

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.concurrent.*;

/**
 * 获取线程池
 *
 * @author yangjikang
 * @date 2019/6/19 10:39
 * @modified By yangjikang
 */
public class TestExecutor {

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        try {
            for (int i = 0; i < 10; i++) {
                final String tempUser = i + "号客户";
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 窗口给" + tempUser + "办理业务...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

在这里插入图片描述
现在我模拟是个用户来办理业务就抛出了异常，为什么呢？以为我们自己写得线程池用的拒绝策略是AbortPolicy
最多只支持最大线程数（代码中是5）加上队列最大界限（代码中是3）的线程数（结果就是8），所以十个用户过来就会抛出RejectedExecutionException异常。

3.3 CallerRunsPolicy拒绝策略

继续看下面的代码：

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.concurrent.*;

/**
 * 获取线程池
 *
 * @author yangjikang
 * @date 2019/6/19 10:39
 * @modified By yangjikang
 */
public class TestExecutor {

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        try {
            for (int i = 0; i < 10; i++) {
                final String tempUser = i + "号客户";
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 窗口给" + tempUser + "办理业务...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

在这里插入图片描述
为什么会有main线程呢？因为我们用的是CallerRunsPolicy拒绝策略
在这里插入图片描述
看一下我们上面介绍的含义，就是谁调用找谁处理，比如：A点的银行网点让你去B点的银行网点办理业务，B银行人满了，跟你说，A让你来的，你去找A办理业务

3.4 DiscardOldestPolicy拒绝策略

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.concurrent.*;

/**
 * 获取线程池
 *
 * @author yangjikang
 * @date 2019/6/19 10:39
 * @modified By yangjikang
 */
public class TestExecutor {

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        try {
            for (int i = 0; i < 10; i++) {
                final String tempUser = i + "号客户";
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 窗口给" + tempUser + "办理业务...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

在这里插入图片描述
2号和3号客户没有办理业务（等待最久的不处理）

3.5 DiscardOldestPolicy拒绝策略

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.concurrent.*;

/**
 * 获取线程池
 *
 * @author yangjikang
 * @date 2019/6/19 10:39
 * @modified By yangjikang
 */
public class TestExecutor {

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        try {
            for (int i = 0; i < 10; i++) {
                final String tempUser = i + "号客户";
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 窗口给" + tempUser + "办理业务...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

在这里插入图片描述
8号和9号没有处理，直接抛弃，因为改线程池最多只能处理8个线程

4. 如何合理的分配线程数

4.1 CPU密集型（运算）

在这里插入图片描述

4.2 IO密集型（需要去数据库，redis等拿数据）

第一种
在这里插入图片描述
第二种
在这里插入图片描述

jikangyang
关注
专栏目录
线程池拒绝策略——CallerRunsPolicy
qq_22253853的博客
06-30 3万+
最近在搞线程池，用到了CallerRunsPolicy这个拒绝策略。 为什么选用CallerRunsPolicy？ 因为考虑到数据一条都不能丢失，所以选择了CallerRunsPolicy策略。保证数据来了不会丢。天真的幻想着这策略好啊！ 经过了一段时间的实战考验，发现了一个问题，数据处理不过来，经常堆积，这样还行能接受。 遇到什么问题？ 在从单线程改用多线程后，阻塞队列在高峰期时经常是满的。 阻塞队列经常是满了，于是考虑从处理效率上入手，（同事解决的）优化了程序处理速度和数据库写入效率，缓解了这个问题，线
CallerRunsPolicy会阻塞主线程吗
咖啡攻城狮的博客
01-09 6465
ThreadPoolExecutor实现原理分析
大多数人不知道的：线程池CallerRunsPolicy()拒绝策略
热门推荐
dabusiGin的博客
04-05 4万+
首先要吐槽一下我这个理解能力，在学习CallerRunsPolicy拒绝策略的时候，搜索了相关的知识，大家都是这么描述的： 第1种： 第2种： 第3种： 第4种：汉化版JDK文档 他们的描述让我看的很懵逼，特别是第3种，仔细看他的测试代码，并没有用CallerRunsPolicy，而是用的AbortPolicy拒绝策略。。。。这是一篇高浏览量的博文，而且多人转载。 其中上面几种情况中写到...
Java线程池原理解析-ThreadPoolExecutor
最新发布
admin3211的博客
07-23 553
【代码】Java线程池原理解析-ThreadPoolExecutor。
线程池拒绝策略
人生就像一场戏
12-02 5833
在学习CallerRunsPolicy拒绝策略的时候，搜索了很多相关的知识，其他博主的描述是这样的： 在学习CallerRunsPolicy拒绝策略的时候，搜索了很多相关的知识，其他博主的描述是这样的： 第1种：第2种：第3种： 举个例子如下图所示，主线程就是平时执行main方法中代码的线程。 再通过一个例子详细说明： public class HanderPolicy { public static void main(String[] args) { ...
说说ThreadPoolExecutor饱和策略CallerRunsPolicy
懂幸福，爱生活
06-21 1万+
之前在文章深入线程池ThreadPoolExecutor中聊到了线程池
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
一、要实现高效的线程池，可以考虑以下几点 二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、...
阻塞线程池 阻塞线程池 阻塞线程池
04-18
阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池...
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用阿里巴巴开源的EasyExcel库结合线程池技术可以有效地实现从Excel文件导入到数据库的过程。先定义sheet的数量和固定大小的线程池数量，每个sheet页做为单独的任务交给线程池...
多线程写法（精易模块线程池和鱼刺模块线程池）
06-02
本篇文章将重点探讨两种线程池实现：精易模块线程池和鱼刺模块线程池，并通过源码分析来展示它们的特点和用法。 首先，精易模块（SanYe Module）是由中国程序员SanYe开发的一系列开源模块，其中包含了线程池的实现...
线程池拒绝策略详解
专业的计算机毕业设计指南
07-27 6001
我们也可以自定义拒绝策略，只需要实现 RejectedExecutionHandler； 需要注意的是，拒绝策略的运行需要指定线程池和队列的容量。
Java ThreadPoolExecutor的拒绝策略CallerRunsPolicy的一个潜在的大坑
明明如月的技术博客
05-07 2万+
一、背景 前面一篇文章转载了ThreadPoolExecutor的几种拒绝策略：https://blog.csdn.net/w605283073/article/details/89930154，讲得很不错。 但是网上介绍使用拒绝策略遇到的大坑的文章不多。 本文介绍其中一个真是故障的场景。 二、问题描述 ThreadPoolExecutor的拒绝策略常用的是DiscardPolicy...
ThreadPoolExecutor里面4种拒绝策略--CallerRunsPolicy
chikoucha6215的博客
08-19 7520
首先介绍一下ThreadPoolExecutor构造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, ...
记录一次生产问题：当线程池打满，CallerRunsPolicy这个策略导致主调线程ThreadLocal变量丢失
booynal的博客
02-21 1717
自己实现接口，在内部直接调用任务的run方法。if(!// 调用执行之前先保留线程本地变量，因为run方法之后会清理线程本地变量 String oldUser = getUser();// 将执行任务之前的变量存回去 setUser(oldUser);} } } }
线程池的执行流程和拒绝策略
Lzm的博客
04-14 894
线程池。
【线程池】线程池原理与参数调优、拒绝策略-CallerRunsPolicy
后端研发工程师Marion的博客
08-23 1341
3. DiscardOldestPolicy：丢弃等待队列中最旧的任务，并执⾏当前任务。2. CallerRunsPolicy：只⽤调⽤者所在的线程来处理任务。1. AbortPolicy：直接丢弃任务，抛出异常，这是默认策略。4. DiscardPolicy：直接丢弃任务，也不抛出异常。
线程池CallerRunsPolicy()拒绝策略
u014644574的博客
05-06 418
线程池CallerRunsPolicy()拒绝策略
线程池拒绝策略-CallerRunsPolicy
OldFat_的博客
12-08 369
可以看到，当阻塞队列打满后且达到最大线程数时，新加入的任务会使用提交者，也就是主线程去执行。此时整体的执行情况是线程池和主线程共同执行任务，直到任务执行完毕。被拒绝任务的处理程序，它直接在execute方法的调用线程中运行被拒绝的任务，除非执行器已关闭，在这种情况下，该任务将被丢弃。：观察CallerRunsPolicy运行机制。
C语言实现线程池详解
"C语言实现线程池的代码示例" C实现线程池是一种优化多线程程序性能的方法，它允许程序预先创建一组线程，然后根据需要调度这些线程执行任务，而不是每次需要时都创建新的线程。线程池通过减少线程创建和销毁的开销...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值