「DUBBO系列」线程池策略源码分析

最新推荐文章于 2024-07-31 03:12:15 发布
最新推荐文章于 2024-07-31 03:12:15 发布
阅读量428 收藏 1
点赞数 1
分类专栏： DUBBO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshixuye/article/details/106608331
版权

1 文章概述

本系列文章已经分析了DUBBO线程模型实现原理，本文简单进行回顾。我们知道DUBBO提供五种线程模型

all
所有消息都派发到业务线程池，包括请求，响应，连接事件，断开事件，心跳

direct
所有消息都不派发到业务线程池，全部在IO线程直接执行

message
只有请求响应消息派发到业务线程池，其它连接断开事件，心跳等消息直接在IO线程执行

execution
只有请求消息派发到业务线程池，响应和其它连接断开事件，心跳等消息直接在IO线程执行

connection
在IO线程上将连接断开事件放入队列，有序逐个执行，其它消息派发到业务线程池

不同线程模型会选择使用IO线程还是业务线程，那么业务线程池采用什么线程池策略是本文需要回答的问题。DUBBO提供了多种线程池策略，选择线程池策略需要在配置文件指定threadpool属性

<dubbo:protocol name="dubbo" threadpool="fixed" threads="100" />
<dubbo:protocol name="dubbo" threadpool="cached" threads="100" />
<dubbo:protocol name="dubbo" threadpool="limited" threads="100" />
<dubbo:protocol name="dubbo" threadpool="eager" threads="100" />

不同线程池策略会创建不同线程池，不同线程池处理任务方式也不相同

fixed
固定线程数量

cached
线程空闲一分钟会被回收，当新请求到来时会创建新线程

limited
线程个数随着任务增加而增加，但不会超过最大阈值。空闲线程不会被回收

eager
当所有核心线程数都处于忙碌状态时，优先创建新线程执行任务

 

2 线程池策略确认时机

public class AllDispatcher implements Dispatcher {
    public static final String NAME = "all";

    @Override
    public ChannelHandler dispatch(ChannelHandler handler, URL url) {
        return new AllChannelHandler(handler, url);
    }
}

public class AllChannelHandler extends WrappedChannelHandler {
    public AllChannelHandler(ChannelHandler handler, URL url) {
        super(handler, url);
    }
}

分析WrappedChannelHandler构造函数

public class WrappedChannelHandler implements ChannelHandlerDelegate {

    public WrappedChannelHandler(ChannelHandler handler, URL url) {
        this.handler = handler;
        this.url = url;
        // 获取线程池自适应扩展点默认FixedThreadPool
        executor = (ExecutorService) ExtensionLoader.getExtensionLoader(ThreadPool.class).getAdaptiveExtension().getExecutor(url);
        String componentKey = Constants.EXECUTOR_SERVICE_COMPONENT_KEY;
        if (Constants.CONSUMER_SIDE.equalsIgnoreCase(url.getParameter(Constants.SIDE_KEY))) {
            componentKey = Constants.CONSUMER_SIDE;
        }
        DataStore dataStore = ExtensionLoader.getExtensionLoader(DataStore.class).getDefaultExtension();
        dataStore.put(componentKey, Integer.toString(url.getPort()), executor);
    }
}

如果配置指定threadpool属性，扩展点加载器会从URL获取属性值加载对应线程池策略

@SPI("fixed")
public interface ThreadPool {
    @Adaptive({Constants.THREADPOOL_KEY})
    Executor getExecutor(URL url);
}

 

3 源码分析

3.1 FixedThreadPool

public class FixedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {

        // 线程名称
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);

        // 线程个数默认200
        int threads = url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);

        // 队列容量默认0
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);

        // 队列容量等于0使用阻塞队列SynchronousQueue
        // 队列容量小于0使用无界阻塞队列LinkedBlockingQueue
        // 队列容量大于0使用有界阻塞队列LinkedBlockingQueue
        return new ThreadPoolExecutor(threads, threads, 0, TimeUnit.MILLISECONDS,
                                      queues == 0 ? new SynchronousQueue<Runnable>()
                                      : (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                                         : new LinkedBlockingQueue<Runnable>(queues)),
                                      new NamedInternalThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }
}

 

3.2 CachedThreadPool

public class CachedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {

        // 获取线程名称
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);

        // 核心线程数默认0
        int cores = url.getParameter(Constants.CORE_THREADS_KEY, Constants.DEFAULT_CORE_THREADS);

        // 最大线程数默认Int最大值
        int threads = url.getParameter(Constants.THREADS_KEY, Integer.MAX_VALUE);

        // 队列容量默认0
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);

        // 线程空闲多少时间被回收默认1分钟
        int alive = url.getParameter(Constants.ALIVE_KEY, Constants.DEFAULT_ALIVE);

        // 队列容量等于0使用阻塞队列SynchronousQueue
        // 队列容量小于0使用无界阻塞队列LinkedBlockingQueue
        // 队列容量大于0使用有界阻塞队列LinkedBlockingQueue
        return new ThreadPoolExecutor(cores, threads, alive, TimeUnit.MILLISECONDS,
                                      queues == 0 ? new SynchronousQueue<Runnable>()
                                      : (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                                         : new LinkedBlockingQueue<Runnable>(queues)),
                                      new NamedInternalThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }
}

 

3.3 LimitedThreadPool

public class LimitedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {

        // 获取线程名称
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);

        // 核心线程数默认0
        int cores = url.getParameter(Constants.CORE_THREADS_KEY, Constants.DEFAULT_CORE_THREADS);

        // 最大线程数默认200
        int threads = url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);

        // 队列容量默认0
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);

        // 队列容量等于0使用阻塞队列SynchronousQueue
        // 队列容量小于0使用无界阻塞队列LinkedBlockingQueue
        // 队列容量大于0使用有界阻塞队列LinkedBlockingQueue
        // keepalive时间设置Long.MAX_VALUE表示不回收空闲线程
        return new ThreadPoolExecutor(cores, threads, Long.MAX_VALUE, TimeUnit.MILLISECONDS,
                                      queues == 0 ? new SynchronousQueue<Runnable>()
                                      : (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                                         : new LinkedBlockingQueue<Runnable>(queues)),
                                      new NamedInternalThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }
}

 

3.4 EagerThreadPool

通过自定义线程执行器可以自定义线程处理策略，我们进行一个对比。

ThreadPoolExecutor普通线程执行器。当线程池核心线程达到阈值时新任务放入队列。当队列已满开启新线程处理。当前线程数达到最大线程数时执行拒绝策略。

EagerThreadPoolExecutor自定义线程执行器。当线程池核心线程达到阈值时，新任务不会放入队列而是开启新线程进行处理（要求当前线程数没有超过最大线程数）。当前线程数达到最大线程数时任务放入队列。队列已满执行拒绝策略。

public class EagerThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {

        // 线程名
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);

        // 核心线程数默认0
        int cores = url.getParameter(Constants.CORE_THREADS_KEY, Constants.DEFAULT_CORE_THREADS);

        // 最大线程数默认Int最大值
        int threads = url.getParameter(Constants.THREADS_KEY, Integer.MAX_VALUE);

        // 队列容量默认0
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);

        // 线程空闲多少时间被回收默认1分钟
        int alive = url.getParameter(Constants.ALIVE_KEY, Constants.DEFAULT_ALIVE);

        // 初始化自定义线程池和队列
        TaskQueue<Runnable> taskQueue = new TaskQueue<Runnable>(queues <= 0 ? 1 : queues);
        EagerThreadPoolExecutor executor = new EagerThreadPoolExecutor(cores,
                threads,
                alive,
                TimeUnit.MILLISECONDS,
                taskQueue,
                new NamedInternalThreadFactory(name, true),
                new AbortPolicyWithReport(name, url));
        taskQueue.setExecutor(executor);
        return executor;
    }
}

public class EagerThreadPoolExecutor extends ThreadPoolExecutor {

    // 提交任务个数
    private final AtomicInteger submittedTaskCount = new AtomicInteger(0);

    @Override
    public void execute(Runnable command) {
        if (command == null) {
            throw new NullPointerException();
        }
        // 任务数自增
        submittedTaskCount.incrementAndGet();
        try {
            // 调用父类方法执行线程任务
            super.execute(command);
        }
        // 抛出拒绝异常
        catch (RejectedExecutionException rx) {
            final TaskQueue queue = (TaskQueue) super.getQueue();
            try {
                // 任务重新放入队列
                if (!queue.retryOffer(command, 0, TimeUnit.MILLISECONDS)) {
                    // 任务重新放入队列失败抛出异常
                    submittedTaskCount.decrementAndGet();
                    throw new RejectedExecutionException("Queue capacity is full.", rx);
                }
            } catch (InterruptedException x) {
                submittedTaskCount.decrementAndGet();
                throw new RejectedExecutionException(x);
            }
        } catch (Throwable t) {
            submittedTaskCount.decrementAndGet();
            throw t;
        }
    }
}

public class TaskQueue<R extends Runnable> extends LinkedBlockingQueue<Runnable> {

    @Override
    public boolean offer(Runnable runnable) {
        if (executor == null) {
            throw new RejectedExecutionException("The task queue does not have executor");
        }

        // 当前线程数
        int currentPoolThreadSize = executor.getPoolSize();

        // 任务数 < 当前线程数表示存在空闲worker线程则任务放入队列等待worker线程处理
        if (executor.getSubmittedTaskCount() < currentPoolThreadSize) {
            return super.offer(runnable);
        }

        // 当前线程数 < 最大线程数返回false表示创建worker线程
        if (currentPoolThreadSize < executor.getMaximumPoolSize()) {
            return false;
        }
        // 当前线程数 > 最大线程数任务放入队列
        return super.offer(runnable);
    }

    public boolean retryOffer(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
        if (executor.isShutdown()) {
            throw new RejectedExecutionException("Executor is shutdown!");
        }
        // 任务重试放入队列
        return super.offer(o, timeout, unit);
    }
}

 

4 文章总结

本文分析了DUBBO线程池策略源码，可以根据不同业务场景选择不同线程池策略。后续文章我们深入分析「DUBBO线程池打满问题」请继续关注。

扫描二维码关注公众号【IT徐胖子】获取更多互联网和技术干货，感谢各位支持

JAVA前线
关注
专栏目录
Apache Dubbo系列：Dubbo的线程池策略
nuoWei_SenLin的博客
10-16 1996
概述 我们上篇文章讲到，Dubbo提供了多种线程模型，是为了尽早的释放I/O线程，把耗时的业务分派给业务线程池，那么这里的线程池是什么类型的线程池呢？是我们所熟知的JAVA线程池吗？并不是，这里的线程池，也是Dubbo的扩展接口ThreadPool。 ThreadPool Dubbo为我们提供了四种类型的线程池，分别是 1、FixedThreadPool(默认)，固定线程数的线程池。 2、LimitedThreadPool，线程池的线程数随着并发量动态增加，但不会超过配置的阈值。 3、Eag.
tomcat和dubbo对于JDK线程池的修改
evasnowind的专栏
08-18 495
文章目录预备知识概述Tomcat线程池源码分析ThreadPoolExecutorTaskQueueDubbo线程池源码分析参考资料 预备知识 计算任务的分类 CPU密集型：需要线程长时间进行的复杂的运算，这种类型的任务需要少创建线程，过多的线程将会频繁引起上文切换，降低任务处理处理速度。 IO密集型：由于线程并不是一直在运行，可能大部分时间在等待 IO 读取/写入数据，增加线程数量可以提高并发度，尽可能多处理任务。 JDK线程池，java.util.concurrent.ThreadPoolE
dubbo源码分析
07-27
公司同事分享的dubbo源码分析，非常好非常好非常好非常好非常好！
dubbo源码分析（一）
dhka8040652的博客
03-02 208
阅读源码的作用 提取设计思路，增强设计能力 理解运行机制，便于快速解决问题以及功能扩展 常见有关dubbo的问题 dubbo的负载均衡是在哪个组件中处理的？ dubbo默认的负载均衡算法是什么？ 如果注册中心挂掉了客户端是否能够继续调用dubbo？ 一个请求从调用端到服务端的处理流程是什么？ 如果你有仔细的研读dubbo的开发文档，大部分问题都是有...
Dubbo源码深度解析(一)
最新发布
weixin_41338970的博客
07-31 1063
本博客讲的是Dubbo源码，将分为几篇，本篇主要聊的是Dubbo如何跟SpringBoot整合，以及Dubbo中提供的一些注解的作用，还包括相关配置信息的读取以及绑定等。
Dubbo的线程池策略
J_bean的博客
03-10 1227
Dubbo的线程池策略剖析和自定义线程池策略
Dubbo 线程池源码解析
chenqun3823的博客
07-22 233
本文首发于个人微信公众号《andyqian》，期待你的关注！ 前言 之前文章《Java线程池ThreadPoolExecutor》《ThreadPoolExecutor 原理解析》中，分别讲述了ThreadPoolExecutor 的概念以及原理，今天就一起来看看其在 Dubb...
10 dubbo源码学习_线程池
shixiaoling123的博客
04-27 1932
dubbo内部采用netty做为通信工具，netty包括bossGroup和workerGroup，bossGroup负责接收accept连接，连接就绪后，将连接交给workerGroup进行处理；默认情况下：bossGroup：线程个数：1个，队列长度，Integer.MAX；创建1个NioEventLoop，这个NioEventLoop主要进行accept操作；
Dubbo 线程池模型
liyong1028826685的专栏
06-03 549
前言 大家好，今天开始给大家分享 — Dubbo 专题之 Dubbo 线程池模型。在前面上个章节中我们讨论了 Dubbo SPI，了解了 Dubbo SPI 其本质是从 JDK 标准的 SPI (Service Provider Interface) 扩展点发现机制加强而来，同时解决了 Java 中 SPI 的一些缺陷。以及我们使用 Dubbo SPI 实现自定义能力的拓展。那本章节我们要讨论的 Dubbo 线程模型也是基于 SPI 实现，那什么是线程模型呢？以及其在我们的项目中有什么作用呢？那么我们在本章
Dubbo源码分析 (八)之线程池EagerThreadPoolExecutor
u011779268的博客
01-27 921
EagerThreadPoolExecutor 为dubbo线程派发器Dipatcher中的一种创建线程池方式；见Dubbo源码分析 (五)之线程5种派发器Dispatcher 直接上代码分析： public class EagerThreadPoolExecutor extends ThreadPoolExecutor { /** * task count 记录正在执行+队列等待执行的任务 */ private final AtomicInteger sub..
Dubbo源码分析
01-29
Dubbo源码分析；模块说明；总体架构；图例说明；各层说明：关系说明：依赖关系；调用链；配置文件解析；配置文件覆盖顺序；暴露服务时序；dubbo的远程调用(NIO机制)以及序列化；RPC 通信过程；消费服务时序；
dubbo源码解析
08-29
dubbo源码解析2.0.pdf,为你详细介绍dubbo的相关包和类，以及相关的方法
Dubbo线程模型与线程池策略
技术原始积累
12-13 546
一、Dubbo的线程模型概述Dubbo 默认的底层网络通讯使用的是 Netty ，服务提供方 NettyServer 使用两级线程池，其中 EventLoopGroup(boss) 主要...
dubbo 线程池调度策略
10-19
Dubbo的线程池调度策略对外提供了三种策略，分别是fixed、cached、limited三类。 1. fixed策略：固定大小的线程池，当线程池达到最大值时，新的任务会在队列中等待。 2. cached策略：无限制大小的线程池，当线程池...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值