首页
会员中心
登录

Dubbo线程池策略详解：Fixed、Cached、Limited与Eager对比

姬轩亦

1. 项目背景与核心价值

在嵌入式开发领域，传统开发模式通常需要开发者掌握C/C++等底层语言，这对于很多应用层开发者来说存在一定门槛。而将Python移植到MCU平台，则能够显著降低嵌入式开发的门槛。APM32F427作为一款基于Arm Cortex-M4内核的国产MCU，其运行频率高达200MHz，Flash容量达到1MB，RAM容量达到256KB，这为运行MicroPython提供了硬件基础。

这个项目的核心价值在于：

  • 为嵌入式开发者提供更友好的开发体验
  • 扩展Python在物联网领域的应用场景
  • 验证国产MCU对高级语言的支持能力
  • 为快速原型开发提供新思路

2. 硬件准备与环境搭建

2.1 硬件选型解析

APM32F427VGT6是极海半导体推出的一款高性能MCU，其主要参数如下：

参数 规格
内核 Cortex-M4
主频 200MHz
Flash 1MB
RAM 256KB
GPIO 多达114个
外设接口 USB, CAN, SPI等

选择这款芯片的原因在于：

  1. 充足的RAM空间能够满足MicroPython运行时的内存需求
  2. 高性能CPU可以较好地处理Python解释器的开销
  3. 丰富的外设接口便于后续功能扩展

2.2 开发环境搭建步骤

  1. 工具链安装：

    • 安装ARM GCC工具链（版本建议9-2020-q2-update）
    • 安装OpenOCD用于调试（版本建议0.11.0）
    • 安装Python3环境（用于构建MicroPython）

  2. 源码获取：

    bash复制git clone --recursive https://github.com/micropython/micropython.git
cd micropython
git submodule update --init

  3. 交叉编译工具配置：
    在Makefile中设置正确的交叉编译工具路径：

    makefile复制CROSS_COMPILE = arm-none-eabi-

  4. 板级支持包准备：
    需要为APM32F427准备特定的板级支持包，包括：

    • 时钟配置（确保200MHz主频正确设置）
    • GPIO驱动实现
    • 串口调试接口配置

3. MicroPython移植关键步骤

3.1 移植框架解析

MicroPython的移植主要涉及三个层次：

  1. 硬件抽象层（HAL）：

    • 实现基本的时钟、GPIO、定时器等驱动
    • 确保中断处理机制正确

  2. 运行时环境：

    • 内存管理适配（堆分配策略）
    • 垃圾回收机制配置

  3. 外设支持：

    • 基础GPIO控制
    • 串口调试接口
    • 其他扩展外设（如SPI、I2C等）

3.2 具体移植步骤

  1. 创建新板级目录：

    bash复制cd ports/stm32/boards
mkdir APM32F427

  2. 编写板级配置文件：
    创建mpconfigboard.h文件，配置基础参数：

    c复制#define MICROPY_HW_BOARD_NAME       "APM32F427"
#define MICROPY_HW_MCU_NAME         "APM32F427VGT6"
#define MICROPY_HW_FLASH_FS_LABEL   "apm32flash"

// 时钟配置
#define MICROPY_HW_CLK_PLLM (25)
#define MICROPY_HW_CLK_PLLN (400)
#define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV2)
#define MICROPY_HW_CLK_PLLQ (8)

  3. 实现GPIO驱动：
    在modmachine.c中实现GPIO控制函数：

    c复制STATIC mp_obj_t machine_pin_obj_init_helper(const machine_pin_obj_t *self, 
    size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    // GPIO初始化实现
}

  4. 内存管理配置：
    调整mpconfigboard.mk中的内存分配：

    makefile复制LD_FILES = boards/APM32F427/APM32F427.ld
MICROPY_PY_THREAD = 0

4. 点灯实验实现细节

4.1 Python脚本编写

在MicroPython环境下，控制LED的Python脚本非常简单：

python复制import machine
import time

# 初始化GPIO
led = machine.Pin('PC13', machine.Pin.OUT)

while True:
    led.value(1)  # 点亮LED
    time.sleep(1)
    led.value(0)  # 熄灭LED
    time.sleep(1)

4.2 固件烧录流程

  1. 编译固件：

    bash复制make BOARD=APM32F427

  2. 生成DFU文件：

    bash复制python3 tools/dfu.py --build build-APM32F427/firmware.bin

  3. 进入DFU模式：

    • 将BOOT0引脚拉高
    • 复位开发板

  4. 使用dfu-util烧录：

    bash复制dfu-util -a 0 -D build-APM32F427/firmware# 1. 概述

本文分享 Dubbo 的线程池策略。在 《精尽 Dubbo 源码分析 —— 线程池》 一文中，我们已经看到了多种线程池和线程队列，Dubbo 是如何选择哪一个使用的呢？

2. 线程池策略

Dubbo 的线程池策略，使用 dubbo.protocol.threadpool 配置项，设置。目前支持四种策略：

  1. fixed 固定大小线程池，启动时建立线程，不关闭，一直持有。(缺省)
  2. cached 缓存线程池，空闲一分钟自动删除，需要时重建。
  3. limited 可伸缩线程池，但池中的线程数只会增长不会收缩。只增长不收缩的目的是为了避免收缩时突然来了大流量引起的性能问题。
  4. eager 优先创建Worker线程池。在任务数量大于corePoolSize但是小于maximumPoolSize时，优先创建Worker来处理任务。当任务数量大于maximumPoolSize时，将任务放入阻塞队列中。阻塞队列充满时抛出RejectedExecutionException。(相比于cached:cached在任务数量超过maximumPoolSize时直接抛出异常而不是将任务放入阻塞队列)

3. 源码实现

在 DubboProtocol#createServer(...) 方法中，我们看到如下代码：

java复制// DubboProtocol.java

private ExchangeServer createServer(URL url) {
    // ... 省略无关代码
    // 添加线程池
    url = url.addParameterIfAbsent(Constants.THREADPOOL_KEY, Constants.DEFAULT_THREA[DPO](https://taotoken.net?utm_source=hardware)OL); // fixed 为默认
    // ... 省略无关代码
    ExchangeServer server;
    try {
        // 创建 ExchangeServer 对象
        server = Exchangers.bind(url, requestHandler);
    } catch (RemotingException e) {
        throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
    }
    // ... 省略无关代码
    return server;
}

  • 在该方法中，我们可以看到，THREADPOOL_KEY 的默认配置是 DEFAULT_THREADPOOL ，即 "fixed" 。

  • 在 Exchangers#bind(URL url, ExchangeHandler handler) 方法中，我们看到如下代码：

    java复制// Exchangers.java

public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handler == null) {
        throw new IllegalArgumentException("handler == null");
    }
    // 添加编解码器
    url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
    // 创建 HeaderExchangeServer 对象
    return getExchanger(url).bind(url, handler);
}

    • 在该方法中，调用 #getExchanger(url) 方法，获得 Exchanger 对象，默认是 HeaderExchanger 对象。代码如下：

      java复制public static Exchanger getExchanger(URL url) {
    String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
    return getExchanger(type);
}

public static Exchanger getExchanger(String type) {
    return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}
      • DEFAULT_EXCHANGER 为 "header" ，即 HeaderExchanger 。

    • 然后，调用 HeaderExchanger#bind(URL url, ExchangeHandler handler) 方法，创建 HeaderExchangeServer 对象。代码如下：

      java复制// HeaderExchanger.java

@Override
public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    // 创建 HeaderExchangeServer 对象
    return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
}

      • 在该方法中，我们看到 Transporters#bind(URL url, ChannelHandler... handlers) 方法，创建 TransportServer 对象。代码如下：

        java复制// Transporters.java

public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handlers == null || handlers.length == 0) {
        throw new IllegalArgumentException("handlers == null");
    }
    ChannelHandler handler;
    if (handlers.length == 1) {
        handler = handlers[0];
    } else {
        // 如果 handlers 数量大于 1，则创建 ChannelHandler 分发器
        handler = new ChannelHandlerDispatcher(handlers);
    }
    // 创建 TransportServer 对象
    return getTransporter().bind(url, handler);
}

public static Transporter getTransporter() {
    return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
}

        • 在该方法中，调用 #getTransporter() 方法，获得 Transporter 自适应拓展对象，默认是 NettyTransporter 对象。

        • 然后，调用 NettyTransporter#bind(URL url, ChannelHandler handler) 方法，创建 NettyServer 对象。代码如下：

          java复制// NettyTransporter.java

@Override
public Server bind(URL url, ChannelHandler handler) throws RemotingException {
    // 创建 NettyServer 对象
    return new NettyServer(url, handler);
}

          • 在该方法中，创建 NettyServer 对象。在构造方法中，会调用 AbstractServer#AbstractServer(URL url, ChannelHandler handler) 父类构造方法。代码如下：

            java复制// AbstractServer.java

public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {
    // 父类构造方法
    super(url, handler);
    // 本地地址
    localAddress = getUrl().toInetSocketAddress();
    // 获得服务器 IP
    String bindIp = getUrl().getParameter(Constants.BIND_IP_KEY, getUrl().getHost());
    // 获得服务器端口
    int bindPort = getUrl().getParameter(Constants.BIND_PORT_KEY, getUrl().getPort());
    if (url.getParameter(Constants.ANYHOST_KEY, false) || NetUtils.isInvalidLocalHost(bindIp)) {
        bindIp = NetUtils.ANYHOST;
    }
    // 绑定地址
    bindAddress = new InetSocketAddress(bindIp, bindPort);
    // 最大可连接数
    this.accepts = url.getParameter(Constants.ACCEPTS_KEY, Constants.DEFAULT_ACCEPTS);
    // 空闲超时时间，默认 60 * 1000 毫秒
    this.idleTimeout = url.getParameter(Constants.IDLE_TIMEOUT_KEY, Constants.DEFAULT_IDLE_TIMEOUT);
    try {
        // 启动服务器
        doOpen();
        if (logger.isInfoEnabled()) {
            logger.info("Start " + getClass().getSimpleName() + " bind " + getBindAddress() + ", export " + getLocalAddress());
        }
    } catch (Throwable t) {
        throw new RemotingException(url.toInetSocketAddress(), null, "Failed to bind " + getClass().getSimpleName() + " on " + getLocalAddress() + ", cause: " + t.getMessage(), t);
    }
    // 创建线程池
    executor = executorRepository.createExecutorIfAbsent(url);
}

            • 在该方法中，会调用 ExecutorRepository#createExecutorIfAbsent(URL url) 方法，创建线程池。代码如下：

              java复制// ExecutorRepository.java

/**
 * 数据交换层服务器线程池
 * key: 服务地址
 * value: 线程池
 */
private final ConcurrentMap<String, ExecutorService> dataExchangeServerExecutor = new ConcurrentHashMap<>();

public ExecutorService createExecutorIfAbsent(URL url) {
    // 获得线程数，即服务提供者线程池的固定大小，默认为 200
    Integer coreSize = url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);
    // 获得队列大小，默认为 0
    Integer queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);
    // 获得线程池名称
    String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);
    // 创建或获得线程池服务对象
    ExecutorService executor = dataExchangeServerExecutor.computeIfAbsent(addr,
            k -> createExecutor(url, name, coreSize, queues));
    return executor;
}

private ExecutorService createExecutor(URL url, String name, int coreSize, int queues) {
    // 创建线程池
    return createExecutor(url, (ThreadPool) ExtensionLoader.getExtensionLoader(ThreadPool.class).getAdaptiveExtension(), name, coreSize, queues);
}

public ExecutorService createExecutor(URL url, ThreadPool threadPool, String name, int coreSize, int queues) {
    // 创建线程池
    return threadPool.getExecutor(url, name, coreSize, queues);
}

              • 在该方法中，会调用 ThreadPool#getExecutor(URL url, String name, int coreSize, int queues) 方法，创建线程池。而 ThreadPool 的默认实现是 FixedThreadPool ，即 fixed 策略。代码如下：

                java复制// FixedThreadPool.java

@Override
public ExecutorService getExecutor(URL url, String name, int cores, int queues) {
    // 创建线程池
    return new ThreadPoolExecutor(cores, cores, 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));
}
                • 根据不同的队列数，使用不同的队列实现：
                  • queues == 0 ， SynchronousQueue 对象。
                  • queues < 0 ， LinkedBlockingQueue 对象。
                  • queues > 0 ，带队列数的 LinkedBlockingQueue 对象。
                • 线程工厂，NamedInternalThreadFactory 对象。
                • 拒绝策略，AbortPolicyWithReport 对象。详细解析，见 《精尽 Dubbo 源码分析 —— 线程池》 的 「4. AbortPolicyWithReport」 部分。

4. 不同策略

在 dubbo-common 模块的 org.apache.dubbo.common.threadpool.support 包下：

4.1 FixedThreadPool

com.alibaba.dubbo.common.threadpool.support.fixed.FixedThreadPool ，实现 ThreadPool 接口，固定大小线程池，启动时建立线程，不关闭，一直持有。代码如下：

java复制public class FixedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        // 线程名
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);
        // 线程数
        int threads = url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);
        // 队列数
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);
        // 创建执行器
        return new ThreadPoolExecutor(threads, threads, 0, TimeUnit.MILLISECONDS,
                queues == 0 ? new SynchronousQueue<Runnable>() :
                        (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                                : new LinkedBlockingQueue<Runnable>(queues)),
                new NamedThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }

}

4.2 CachedThreadPool

com.alibaba.dubbo.common.threadpool.support.cached.CachedThreadPool ，实现 ThreadPool 接口，缓存线程池，空闲一定时长，自动删除，需要时重建。代码如下：

java复制public class CachedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        // 线程池名
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);
        // 核心线程数
        int cores = url.getParameter(Constants.CORE_THREADS_KEY, Constants.DEFAULT_CORE_THREADS);
        // 最大线程数
        int threads = url.getParameter(Constants.THREADS_KEY, Integer.MAX_VALUE);
        // 队列数
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);
        // 线程空闲时长
        int alive = url.getParameter(Constants.ALIVE_KEY, Constants.DEFAULT_ALIVE);
        // 创建执行器
        return new ThreadPoolExecutor(cores, threads, alive, TimeUnit.MILLISECONDS,
                queues == 0 ? new SynchronousQueue<Runnable>() :
                        (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                                : new LinkedBlockingQueue<Runnable>(queues)),
                new NamedThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }

}
  • 默认情况下，cores = 0 threads = Integer.MAX_VALUE queues = 0 alive = 60 * 1000 毫秒。
  • 和 FixedThreadPool 不同的是：
    • 队列使用 SynchronousQueue 队列。
    • 线程空闲时长是 alive 参数，默认为 60 秒。意味着，空闲超过 60 秒的线程，会被回收。
    • 最大线程数为 threads 参数，默认为 Integer.MAX_VALUE 。

4.3 LimitedThreadPool

com.alibaba.dubbo.common.threadpool.support.limited.LimitedThreadPool ，实现 ThreadPool 接口，可伸缩线程池，但池中的线程数只会增长不会收缩。只增长不收缩的目的是为了避免收缩时突然来了大流量引起的性能问题。代码如下：

java复制public class LimitedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        // 线程名
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);
        // 核心线程数
        int cores = url.getParameter(Constants.CORE_THREADS_KEY, Constants.DEFAULT_CORE_THREADS);
        // 最大线程数
        int threads = url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);
        // 队列数
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);
        // 创建执行器
        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 NamedThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }

}
  • 和 FixedThreadPool 不同的是：
    • 队列使用 SynchronousQueue 队列。
    • 线程空闲时长是 Long.MAX_VALUE 毫秒。意味着，空闲线程不会被回收。
    • 最大线程数为 threads 参数，默认为 200 。

4.4 EagerThreadPool

com.alibaba.dubbo.common.threadpool.support.eager.EagerThreadPool ，实现 ThreadPool 接口，在任务数量大于 corePoolSize 但是小于 maximumPoolSize 时，优先创建线程来处理任务。当任务数量大于 maximumPoolSize 时，将任务放入阻塞队列中。阻塞队列充满时抛出 RejectedExecutionException 异常。代码如下：

java复制public class EagerThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        // 线程名
        String name = url.getParameter(Constants.THREAD_NAME_KEY, Constants.DEFAULT_THREAD_NAME);
        // 核心线程数
        int cores = url.getParameter(Constants.CORE_THREADS_KEY, Constants.DEFAULT_CORE_THREADS);
        // 最大线程数
        int threads = url.getParameter(Constants.THREADS_KEY, Integer.MAX_VALUE);
        // 队列数
        int queues = url.getParameter(Constants.QUEUES_KEY, Constants.DEFAULT_QUEUES);
        // 线程空闲时长
        int alive = url.getParameter(Constants.ALIVE_KEY, Constants.DEFAULT_ALIVE);
        // 创建执行器
        // init queue and executor
        TaskQueue<Runnable> taskQueue = new TaskQueue<Runnable>(queues <= 0 ? 1 : queues);
        EagerThreadPoolExecutor executor = new EagerThreadPoolExecutor(cores,
                threads,
                alive,
                TimeUnit.MILLISECONDS,
                taskQueue,
                new NamedThreadFactory(name, true),
                new AbortPolicyWithReport(name, url));
        taskQueue.setExecutor(executor);
        return executor;
    }

}
  • 默认情况下，cores = 0 threads = Integer.MAX_VALUE queues = 0 alive = 60 * 1000 毫秒。
  • 和 CachedThreadPool 不同的是：
    • 队列使用 TaskQueue 队列。并且，该队列带有 executor 属性，即线程池。
    • 线程池使用 EagerThreadPoolExecutor 执行器。

4.4.1 TaskQueue

org.apache.dubbo.common.threadpool.support.eager.TaskQueue ，继承 LinkedBlockingQueue 类，任务队列。代码如下：

java复制public class TaskQueue<R extends Runnable> extends LinkedBlockingQueue<Runnable> {

    private static final long serialVersionUID = -2635853580887179627L;

    /**
     * 线程池
     */
    private EagerThreadPoolExecutor executor;

    public TaskQueue(int capacity) {
        super(capacity);
    }

    public void setExecutor(EagerThreadPoolExecutor exec) {
        executor = exec;
    }

    @Override
    public boolean offer(Runnable runnable) {
        if (executor == null) {
            throw new RejectedExecutionException("The task queue does not have executor!");
        }
        // 当前线程数
        int currentPoolThreadSize = executor.getPoolSize();
        // 有空闲线程，添加到队列中
        if (executor.getSubmittedTaskCount() < currentPoolThreadSize) {
            return super.offer(runnable);
        }
        // 当前线程数小于最大线程数，返回 false ，让线程池创建新的线程
        if (currentPoolThreadSize < executor.getMaximumPoolSize()) {
            return false;
        }
        // 添加到队列中
        return super.offer(runnable);
    }

    /**
     * 重试执行任务
     *
     * 1. 返回当前队列
     * 2. 返回父类队列
     *
     * @return 队列
     */
    public RetryOfferTask<Runnable> retryOffer(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
        if (executor.isShutdown()) {
            throw new RejectedExecutionException("Executor is shutdown!");
        }
        return new RetryOfferTask<Runnable>(o, this, unit.toMillis(timeout));
    }

}
  • executor 属性，线程池。通过 #setExecutor(EagerThreadPoolExecutor executor) 方法设置。
  • #offer(Runnable runnable) 方法，代码如下：
    • 当前线程数大于提交的任务数时，调用父类方法，添加到队列中。
    • 当前线程数小于最大线程数时，返回 false ，让线程池创建新的线程。
    • 即，在任务数量大于 corePoolSize 但是小于 maximumPoolSize 时，优先创建线程来处理任务。
  • #retryOffer(Runnable o, long timeout, TimeUnit unit) 方法，重试执行任务。目前该方法未被使用。

4.4.2 EagerThreadPoolExecutor

org.apache.dubbo.common.threadpool.support.eager.EagerThreadPoolExecutor ，继承 ThreadPoolExecutor 类，优先创建线程来处理任务。代码如下：

java复制public class EagerThreadPoolExecutor extends ThreadPoolExecutor {

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

    public EagerThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit, TaskQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    public int getSubmittedTaskCount() {
        return submittedTaskCount.get();
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        submittedTaskCount.decrementAndGet();
    }

    @Override
    public void execute(Runnable command) {
        if (command == null) {
            throw new NullPointerException();
        }
        // 提交的任务数量 +1
        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) {
            // 提交的任务数量 -1
            submittedTaskCount.decrementAndGet();
            throw t;
        }
    }

}
  • submittedTaskCount 属性，提交的任务数量。
  • #execute(Runnable command) 方法，提交任务给线程池执行。
    • 提交的任务数量 +1 。
    • 调用父类方法，执行任务。
    • 若被拒绝，调用 TaskQueue#retryOffer(command, 0, TimeUnit.MILLISECONDS) 方法，重试添加到队列中。
    • 若发生异常，提交的任务数量 -1 。
  • #afterExecute(Runnable r, Throwable t) 方法，执行任务完成时，提交的任务数量 -1 。

5. 如何选择线程池策略

笔者整理了一张三种线程池策略的对比图：

策略 核心线程数 最大线程数 队列 队列长度 线程空闲时间 拒绝策略
fixed dubbo.protocol.threads 默认 200 同核心线程数 SynchronousQueue 0 0 AbortPolicyWithReport
cached dubbo.protocol.corethreads 默认 0 dubbo.protocol.threads 默认 Integer.MAX_VALUE SynchronousQueue 1 dubbo.protocol.alive 默认 60 * 1000 AbortPolicyWithReport
limited dubbo.protocol.corethreads 默认 0 dubbo.protocol.threads 默认 200 SynchronousQueue 0 Long.MAX_VALUE AbortPolicyWithReport
eager dubbo.protocol.corethreads 默认 0 dubbo.protocol.threads 默认 Integer.MAX_VALUE TaskQueue dubbo.protocol.queues 默认 0 dubbo.protocol.alive 默认 60 * 1000 AbortPolicyWithReport
  • 在绝大多数情况下，使用 fixed 策略。具体的原因，胖友可以搜索下，为什么 SynchronousQueue 的性能好。
  • 在极端情况下，使用 eager 策略。例如说，耗时高，且并发量波动大。

内容推荐

ABB AO2060气体分析仪：TDLAS技术工业应用解析
TDLAS（可调谐二极管激光吸收光谱）技术是一种基于气体分子特征吸收谱线的高精度检测方法，通过激光与气体分子的相互作用实现非接触式测量。其核心原理是利用特定波长的激光扫描气体吸收谱线，结合比尔-朗伯定律计算浓度。该技术在工业气体监测领域具有显著优势，如高精度、抗干扰能力强等。ABB AO2060气体分析仪作为TDLAS技术的工业级应用典范，采用了波长调制技术和二次谐波检测等先进信号处理技术，显著提升了信噪比。在钢铁厂、水泥厂等复杂工业环境中，AO2060展现了卓越的稳定性和精度，广泛应用于脱硝系统、烟气监测等场景。
基于MPU6050的智能手势识别手套设计与实现
手势识别是人机交互领域的重要技术，通过传感器捕捉人体动作实现自然交互。其核心原理是利用加速度计和陀螺仪采集运动数据，通过算法解析手势意图。在嵌入式系统中，MPU6050传感器因其集成DMP功能，能有效降低MCU计算负担。本方案采用STC89C52单片机与MPU6050组合，构建低成本手势识别系统，通过蓝牙传输实现主从机交互。该系统特别适合智能家居控制场景，相比传统触摸方式，具有非接触、更卫生的优势。关键技术涉及传感器数据滤波、手势阈值算法和低功耗蓝牙通信，为物联网终端设备提供了实用的交互解决方案。
RISC-V嵌入式开发：行空板K10移植MimiClaw与飞书集成实践
嵌入式系统开发中，跨平台移植是连接不同硬件架构与软件生态的关键技术。RISC-V作为新兴的精简指令集架构，与x86等传统架构存在显著差异，需要通过硬件抽象层和操作系统适配层实现兼容。在行空板K10这类资源受限的嵌入式平台上，合理的内存管理和实时性优化尤为重要。通过分层架构设计，可以高效移植机器人控制框架如MimiClaw，并结合飞书等SaaS应用实现远程监控与团队协作。这种嵌入式与云服务的融合方案，在工业自动化、智能设备等领域具有广泛应用前景，展示了RISC-V生态的灵活性与扩展性。
Visual Studio C++头文件报红问题解决方案
在C++开发中，头文件管理是项目组织的重要环节。Visual Studio作为主流IDE，其IntelliSense系统与编译器采用不同的路径解析机制，常导致头文件报红但编译通过的矛盾现象。理解VS的工程配置原理，掌握附加包含目录设置和IntelliSense缓存刷新等技巧，能有效解决多项目开发中的路径问题。通过合理使用$(SolutionDir)等宏定义和模块化目录结构设计，可以构建可移植性强的跨平台C++项目。本文基于实际工程经验，详细解析Visual Studio环境下C++项目的头文件引用最佳实践，特别针对多项目解决方案中的常见报错场景提供完整解决方案。
编程竞赛自动评分算法设计与实现
字符串比对是计算机科学中基础且重要的操作，其核心原理是通过逐字符比较实现模式匹配。在算法设计中，时间复杂度O(M×N)的暴力解法适用于小规模数据，而大规模场景则需要更高效的算法如KMP。这类技术在自动评分系统、文本差异检测等工程实践中广泛应用。本文以编程竞赛评分系统为例，详细解析如何通过字符串比对统计正确答题数，并处理同分情况下的字典序排序。其中涉及输入输出优化、浮点数精度控制等关键技术点，为开发在线考试系统等实际应用提供参考方案。
SM3哈希算法常量表(T表)设计与安全实现
在密码学算法中，常量表(T表)是实现安全哈希函数的基础组件。以国产SM3算法为例，其采用分段设计的T表通过数学构造确保算法安全性——前16轮使用0x79cc4519常量实现快速扩散，后48轮切换为0x7a879d8a增强抗差分攻击能力。这两个基于圆周率π生成的魔数，在硬件实现时需考虑缓存对齐、时序恒定等安全实践，同时可通过SIMD指令优化性能。理解T表的设计原理对实现符合GM/T 0004标准的密码系统至关重要，其分段策略和数学特性为区块链、物联网等场景提供了安全高效的哈希计算基础。
STM32F4三相无刷电机FOC控制器设计与实现
磁场定向控制(FOC)是现代电机驱动系统的核心技术，通过坐标变换将三相交流电机解耦为直流电机控制，显著提升转矩响应和能效表现。其核心原理包含Clarke/Park变换、空间矢量调制(SVM)及多闭环PID控制，在工业伺服、无人机电调等场景广泛应用。本文基于STM32F4主控与三菱IPM模块，详解30A级FOC驱动器的硬件设计要点，包括4层PCB布局策略、功率回路优化及保护电路实现，并分享双闭环电流控制算法在FreeRTOS实时系统中的工程实践。方案特别强调量产可靠性，提供经过验证的PCB设计规范与参数整定技巧，助力工程师快速实现高性能电机驱动开发。
无线充电系统仿真：关键技术与实践指南
电磁场耦合仿真是现代无线充电系统设计的核心技术，通过精确建模可显著提升能量传输效率并解决电磁兼容性问题。其原理基于磁场耦合理论，涉及线圈设计、谐振匹配等关键技术环节，在ANSYS Maxwell等专业软件中实现多物理场耦合分析。这种仿真方法具有重要工程价值，能大幅降低开发成本，缩短产品上市周期，广泛应用于消费电子、电动汽车等领域。针对无线充电系统特有的效率优化和EMC设计挑战，工程师需要掌握参数化扫描、谐振拓扑选择等实践技巧，其中线圈几何参数优化和SS/SP拓扑匹配是提升传输效率的关键热词。
边缘计算与机器人操作系统(ROS)的融合应用
边缘计算作为分布式计算的重要分支，通过在数据源头就近处理信息，有效解决了传统云计算在延迟和带宽上的瓶颈。其核心技术原理是将计算能力下沉到网络边缘，与云端形成协同。在工业自动化领域，这种架构特别适合机器人操作系统(ROS)等需要实时响应的场景。以英伟达Jetson和Drive Orin平台为代表的边缘计算硬件，通过异构计算架构实现了高性能AI运算与功能安全的平衡。典型应用包括自动驾驶域控制器和工业机械臂智能化改造，其中多传感器融合和实时SLAM等关键技术都依赖边缘设备的强大算力。随着5G和AI技术的进步，边缘计算正在推动从单一设备智能到系统智能的演进，布谷鸟科技等企业的创新产品展示了该技术在机器人领域的突破性应用。
电动汽车充电通信协议：IEC 61851与ISO 15118解析
电动汽车充电通信协议是智能充电基础设施的核心技术，涉及硬件接口与软件通信的标准化。IEC 61851和ISO 15118系列标准分别从电气接口和通信协议两个维度定义了车桩交互规则。IEC 61851-1作为基础规范，明确了充电模式的分类，如Mode 3交流充电和Mode 4直流快充，而ISO 15118-2引入了电力线通信（PLC）和TLS加密，支持即插即充（Plug & Charge）等高级功能。这些协议不仅提升了充电效率，还通过安全认证和状态机控制确保了兼容性与可靠性。随着技术演进，ISO 15118-20进一步扩展了无线通信选项，支持V2G和智能充电场景。对于工程师而言，深入理解这些标准的状态转换、证书管理和EMC设计是开发高性能充电桩的关键。
无感FOC算法在电机控制中的应用与实现
无感FOC（Field Oriented Control）是一种先进的电机控制技术，通过算法实现转子位置估算，无需依赖机械传感器。其核心原理基于电机反电动势方程，通过滑模观测器等算法实时估算转子位置和速度。这种技术不仅降低了系统成本，还提高了可靠性和转速范围。无感FOC广泛应用于永磁同步电机（PMSM）和无刷直流电机（BLDC）控制，特别适合工业伺服系统和高性能驱动场景。开源项目中的滑模观测器实现和参数整定方法为工程师提供了实用参考。
动态版本控制的WiFi数据传输方案设计与实现
WiFi数据传输在现代物联网和工业自动化中扮演着关键角色。传统固定格式的数据传输方式在面对协议变更或设备升级时往往需要停机维护，严重影响生产效率。动态版本控制技术通过将协议栈分层设计，实现了数据结构的实时修改能力，其核心技术包括差分编码和TLV结构。这种方案特别适用于需要持续运行的工业场景，如智能制造产线监控和设备远程升级。通过ESP32等嵌入式平台的实际测试表明，动态版本控制系统仅增加少量内存开销，却能显著提升系统灵活性。在智能农业和工业物联网等应用场景中，该技术可以大幅降低运维成本，实现无缝协议迁移。
Qt事件系统与事件循环深度解析
事件处理机制是GUI编程的核心基础，Qt框架通过抽象层将不同操作系统的原生事件转换为统一的事件对象模型。其事件传递遵循严格的组件层级规则，从QApplication派发到具体Widget的事件处理函数。事件过滤器(eventFilter)技术提供了灵活的事件拦截能力，常用于实现全局快捷键等功能。QEventLoop作为异步编程基石，管理着用户输入、窗口系统、定时器等多类事件的处理循环。在跨线程通信场景中，自定义事件与postEvent()的线程安全特性尤为重要。掌握这些事件处理技术，能够帮助开发者构建响应迅速、资源高效的跨平台应用，特别是在桌面软件开发、嵌入式界面等场景中发挥关键作用。
STM32定时器高级功能实战：刹车与同步控制
定时器是嵌入式系统的核心外设，STM32的高级定时器TIM1通过硬件级保护机制和精准同步控制，为工业应用提供可靠保障。其刹车功能采用双重保护设计（引脚刹车+时钟安全系统），可在微秒级切断PWM输出，确保电机控制等场景的安全性。同步控制方面，通过COM事件实现多通道ns级同步更新，结合外部触发清除功能构建快速响应体系。这些特性在数字电源控制、步进电机驱动等场景展现出色性能，实测可将相序切换抖动降低至50ns内。本文以寄存器级实操解析TIM1的刹车恢复机制、外部事件清除等高级功能，帮助开发者掌握工业级定时器应用技巧。
QT实战：工业报警页面布局设计与实现
在工业控制系统中，报警页面是监控人机界面的核心组件，负责实时展示设备异常状态。QT框架凭借其跨平台特性和丰富的UI库，成为开发此类专业界面的首选。通过QHBoxLayout、QVBoxLayout等布局管理器的组合使用，可以构建响应式界面架构；而QTableView与模型-视图架构的结合，则能高效处理大规模报警数据。本文以工业级报警系统为例，详解如何利用QT实现包含实时报警列表、状态指示灯和操作控制区的专业界面，其中重点介绍了QSS样式表定制和性能优化技巧，这些方法同样适用于SCADA、MES等工业软件的前端开发。
AGV伺服驱动器开发：精准控制与能效优化方案
伺服驱动器作为工业自动化设备的核心部件，通过精确控制电机运动实现机械系统的精准定位。其核心原理基于闭环控制算法，将位置、速度指令转化为三相电流输出，具有响应快、精度高的技术特点。在AGV（自动导引运输车）这类动态负载场景中，伺服系统需要特别解决频繁启停、抗扰动和能效优化等工程挑战。通过自适应PID算法和T型三电平拓扑等创新设计，现代伺服驱动器已能在±0.1mm定位精度下实现95%以上的能效比，广泛应用于智能物流和柔性生产线。本文以AGV伺服驱动器为例，详解其硬件设计、控制算法开发与振动抑制等关键技术，特别分享了IPM模块选型和EtherCAT通信等实战经验。
Qt6音乐播放器开发：跨平台多媒体应用实践
现代跨平台GUI开发中，Qt框架的多媒体模块（QMediaPlayer/QAudioOutput）为音视频应用提供了高效解决方案。其核心原理是通过硬件加速和原生API集成实现低延迟播放，支持MP3/AAC/FLAC等主流格式。在工程实践中，该技术组合特别适合开发音乐播放器、流媒体客户端等场景，能有效平衡性能与跨平台兼容性。本文以Qt6.9.2为例，详解如何利用MVC模式构建播放器核心架构，涉及元数据异步加载、频谱分析等关键技术点，并针对Windows/macOS/Linux平台的适配问题提供优化方案。通过QML与C++混合编程、QAudioProbe实时处理等实践，开发者可深入掌握Qt多媒体开发精髓。
车载系统中浮点数与整型数转换的核心技术与实践
数据类型转换是嵌入式系统开发中的基础操作，尤其在车载系统这类对精度和安全性要求极高的场景。浮点数采用IEEE 754标准存储，包含符号位、指数位和尾数位，与整型数的二进制补码表示存在本质差异。理解这些差异对于处理传感器数据、控制信号和算法运算至关重要。在工程实践中，类型转换不仅涉及基础的数据表示问题，还需要考虑性能优化、边界条件处理以及行业规范（如MISRA-C）的合规性。车载系统开发中，合理的类型转换策略能有效提升系统稳定性和计算精度，特别是在处理CAN信号、车辆定位等关键功能时。通过标准库函数、定点数运算等技术手段，开发者可以规避常见的转换陷阱，满足车载电子控制单元(ECU)的严苛要求。
STM32定时器从模式实现高精度PWM测量
PWM（脉冲宽度调制）是嵌入式系统中广泛使用的信号调制技术，通过调节脉冲宽度来控制功率输出。其核心参数占空比的精确测量对电机控制、电源管理等应用至关重要。传统输入捕获方法存在中断延迟问题，而STM32定时器的从模式（Slave Mode）和触发输入（Trigger Input）功能提供了硬件级解决方案。该技术利用定时器复位模式（Reset Mode）实现纳秒级边沿检测，特别适合工业自动化中的高频PWM信号测量。通过合理配置ETR引脚和滤波器参数，可在不占用CPU资源的情况下实现0.1%测量精度，广泛应用于电机转速监测、LED调光等场景。
信捷PLC电子追剪控制技术解析与应用
电子追剪技术是工业自动化中实现高精度定长切割的关键工艺，广泛应用于包装、印刷和纺织等行业。其核心原理是通过PLC控制伺服系统实现切割工具与材料的同步运动，结合电子凸轮技术替代传统机械凸轮，显著提升精度并降低维护成本。信捷PLC作为国产PLC代表，其电子追剪解决方案在中小型生产线中展现出高性价比优势。该技术通过高速信号同步和位置闭环修正，可将切割精度提升至±0.2mm，同时支持S型加减速曲线优化机械冲击。典型应用场景包括薄膜分切、瓦楞纸板切割等连续生产线，配合视觉系统还能实现智能避让切割，是工业4.0时代智能制造的重要技术支撑。
已经到底了哦
精选内容
1 Android系统定制：Settings应用列表过滤技术详解2 电子凸轮技术：位置跟随与S曲线运动控制实现3 鸿蒙多线程并行渲染架构解析与优化实践4 工业级逆变系统设计与实现：从拓扑结构到调试优化5 Linux环境下STM32开发：HAL库配置与项目实战6 STM32 GPIO模式解析与LED驱动实践7 STM32智能手环开发：多传感器融合与低功耗设计实践8 智能汽车五大功能域控制器详解与开发实践9 RK3576开发板YT8521以太网驱动移植与调试实战10 肌电手势识别技术：原理、挑战与应用实践
热门内容
1 表贴式PMSM直接转矩控制仿真与实践2 Linux系统NVIDIA显卡驱动问题排查与解决指南3 C++11核心特性解析：内联函数与智能指针实战4 工业自动化中0.1mm分辨率对系统稳定性的影响5 Linux内核struct resource详解与驱动开发实践6 西门子S7-200 PLC自主PID算法实现工业恒温控制7 三菱PLC与编码器实现卷帘门智能控制方案8 三极管推挽电路设计与应用实战指南9 电阻故障诊断与硬件调试实战指南10 Boost.Asio网络编程与高性能服务器设计
最新内容
电动汽车OBC电源设计：PFC+LLC拓扑与数字控制实现
功率因数校正(PFC)和LLC谐振变换器是电力电子领域的核心拓扑结构，通过软开关技术实现高效能量转换。PFC级采用临界导通模式Boost拓扑，可达到THD<5%的输入质量；LLC级利用谐振特性实现零电压开关(ZVS)，显著降低开关损耗。在新能源车载充电机(OBC)设计中，这种PFC+LLC两级架构能实现>95%的系统效率，并支持宽输出电压范围。数字控制方案通过DSP实现闭环调节，结合第三代半导体器件如GaN MOSFET，可进一步提升功率密度。该技术方案在电动汽车充电桩、数据中心电源等场景具有广泛应用价值。
YOLOv5在FPGA边缘计算的实时物体识别优化实践
物体识别作为计算机视觉的核心技术，通过深度学习模型实现像素级语义理解。YOLOv5凭借其轻量级架构和高效推理特性，成为边缘计算场景的理想选择。结合FPGA的并行计算优势，可显著提升模型在资源受限环境下的推理性能。在智慧餐饮、工业质检等场景中，这种技术组合能实现毫秒级识别响应，同时保持高能效比。以Xilinx Zynq平台为例，通过模型量化、硬件加速设计等方法，YOLOv5s模型可获得8-12倍速度提升，功耗降低60%以上。这些优化手段为智能结算台、实时质检系统等应用提供了可靠的技术支撑。
隔离变换器设计核心指标与开关利用率优化
隔离变换器作为电力电子系统中的关键组件，通过磁耦合实现电气隔离，在阻断共模干扰的同时完成电压变换。其核心技术指标包括电压转换效率、隔离耐压、温升控制等，直接影响系统可靠性和EMI性能。在新能源发电、医疗设备等高安全要求场景中，优化开关利用率可显著提升变换器效能，涉及占空比算法、死区控制、软开关等关键技术。通过合理设计变压器匝比、采用三明治绕法等手段，既能满足安规要求，又能降低漏感损耗。工程实践中，需平衡成本与可靠性，如选用CTI≥600的绝缘材料，配合热设计将温升降至安全范围。
电压模式升压变换器III型补偿器设计与MATLAB实现
DC-DC升压变换器是电力电子系统中的核心组件，通过开关器件实现电压转换。电压模式控制作为经典控制方法，通过直接调节输出电压维持系统稳定。III型补偿器凭借其双零点双极点的拓扑结构，能有效提升相位裕度，特别适合处理升压变换器的右半平面零点问题。本文结合MATLAB Mixed Signal Blockset工具，详细解析了从功率级建模、频率响应分析到补偿器参数自动调谐的全流程设计方法，展示了如何通过系统级联和systune优化实现45°相位裕度的稳定系统。该方案为工程师提供了可复用的电力电子控制设计范式，适用于工业电源、新能源转换器等高频开关电源场景。
多线程编程与同步机制实战指南
多线程编程是现代软件开发的核心技术，尤其在多核处理器普及的今天，合理利用线程可以显著提升程序性能。线程同步机制包括互斥锁、条件变量和读写锁等，是保证线程安全的关键。通过细粒度锁控制和无锁编程等技术，开发者可以在保证数据一致性的同时最大化并发性能。这些技术在GUI响应优化、高并发服务器、数据处理流水线等场景都有广泛应用。本文结合Linux系统特性和C++11/14标准，深入解析线程模型选择、同步原语使用技巧以及常见并发问题的解决方案。
S7-1200 Modbus RTU主站结构块设计与优化
Modbus RTU作为工业自动化领域广泛应用的通信协议，其主从架构通过串行通信实现PLC与变频器、仪表等设备的数据交互。协议采用请求-响应模式，通过功能码和寄存器地址访问设备数据。在工程实践中，传统轮询方式存在代码冗余和维护困难的问题。通过结构化编程思想封装通信逻辑，可构建可复用的Modbus主站功能块，实现配置驱动的通信管理。这种方案特别适用于西门子S7-1200/S7-1500 PLC平台，在TIA Portal开发环境中，通过SCL语言实现的数组配置和自动调度机制，能显著提升多从站系统的开发效率和通信稳定性。典型应用场景包括PVC配料系统等需要管理数十个从站的工业自动化项目，其中优化的轮询算法和错误处理机制可确保99.95%以上的通信成功率。
备忘录模式：对象状态管理的游戏存档机制
备忘录模式是行为设计模式中的经典实现，其核心原理是通过封装对象状态快照实现状态回溯。该模式通过Originator、Memento和Caretaker三个角色的协作，在保持对象封装性的前提下实现状态保存与恢复。在工程实践中，备忘录模式广泛应用于撤销/重做功能、事务回滚、游戏存档等场景，特别适合需要状态回溯的业务需求。结合C++实现示例可见，通过智能指针管理备忘录生命周期、使用双栈结构实现多级撤销/重做是典型技术方案。在文本编辑器、图形软件和金融系统等高频变更场景中，合理运用备忘录模式能有效提升系统的容错性和用户体验。
智能仿生手的人机共享控制技术解析与应用
人机共享控制（Shared Control）是智能假肢领域的核心技术，通过融合用户的肌电信号（sEMG）与机器自主决策能力，实现更自然的人机交互。其原理在于多模态传感器（如IMU、压力传感器）的数据融合与深度学习算法，显著降低用户的认知负荷。这项技术在康复工程中具有重要价值，尤其能提升前臂截肢患者的日常抓握效率。典型应用场景包括精确抓取、复杂环境适应等，其中仿生手的可变刚度腱传动系统和实时意图识别算法尤为关键。当前系统已通过临床验证，抓取成功率达96.2%，为智能假肢设定了新标准。
定制化锂电池组装设备的技术突破与应用实践
锂电池作为新能源存储的核心技术，其制造工艺直接影响电池性能和安全性。随着电动汽车、储能系统等应用场景的多样化发展，传统标准化生产线已难以满足不同尺寸、化学体系的电池生产需求。模块化设计和智能控制成为解决这一难题的关键技术路径，通过机械结构快速换型、视觉引导精密对位等创新方案，实现设备柔性化生产能力。在工业4.0背景下，这类定制化组装系统融合了机器视觉、数字孪生等前沿技术，特别适用于特种车辆、医疗设备等对精度和可靠性要求严苛的领域。实际案例表明，采用模块化设计的锂电池组装设备可将改造成本降低60%，同时保持±0.1mm的定位精度。
C++17 shared_mutex：读写锁原理与高性能并发实践
读写锁(RW Lock)是并发编程中的关键同步机制，通过区分读/写访问模式显著提升多线程性能。其核心原理基于读操作可共享而写操作需独占的特性，C++17标准引入的shared_mutex提供了标准实现。在工程实践中，该技术特别适用于配置管理、缓存系统等读多写少场景，配合RAII模式可确保线程安全与异常安全。测试表明在读占比85%的典型场景中，相比普通mutex可实现3倍吞吐量提升。本文深入解析shared_mutex的底层实现、RAII封装技巧以及读写锁升级等常见陷阱解决方案。
已经到底了哦
@2026 北京创新乐知网络技术有限公司 京ICP备19004658号-18