springboot整合多线程

最新推荐文章于 2025-03-28 21:08:15 发布
最新推荐文章于 2025-03-28 21:08:15 发布
阅读量748 收藏 5
点赞数
分类专栏： springboot 文章标签： spring boot java spring
原文链接：https://mp.weixin.qq.com/s/vDqqE2PiNIsojgrQRb0QWA
版权

springboot整合多线程

本文参考网址:

https://mp.weixin.qq.com/s/vDqqE2PiNIsojgrQRb0QWA

SpringBoot使用@Async

https://mp.weixin.qq.com/s/xwTMXuHEpgFipiHrOuYgNA

ruoyi开源项目使用多线程配置

ruoyi开源项目地址

https://gitee.com/y_project/RuoYi-Vue

具体多项成配置

https://gitee.com/y_project/RuoYi-Vue/blob/master/ruoyi-framework/src/main/java/com/ruoyi/framework/config/ThreadPoolConfig.java

ruoyi项目重 , 线程池具体配置

package com.ruoyi.framework.config;

import com.ruoyi.common.utils.Threads;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 线程池配置
 *
 * @author ruoyi
 **/
@Configuration
public class ThreadPoolConfig
{
    // 核心线程池大小
    private int corePoolSize = 50;

    // 最大可创建的线程数
    private int maxPoolSize = 200;

    // 队列最大长度
    private int queueCapacity = 1000;

    // 线程池维护线程所允许的空闲时间
    private int keepAliveSeconds = 300;

    @Bean(name = "threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor()
    {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(maxPoolSize);
        executor.setCorePoolSize(corePoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        // 线程池对拒绝任务(无线程可用)的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    /**
     * 执行周期性或定时任务
     */
    @Bean(name = "scheduledExecutorService")
    protected ScheduledExecutorService scheduledExecutorService()
    {
        return new ScheduledThreadPoolExecutor(corePoolSize,
                new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build(),
                new ThreadPoolExecutor.CallerRunsPolicy())
        {
            @Override
            protected void afterExecute(Runnable r, Throwable t)
            {
                super.afterExecute(r, t);
                Threads.printException(r, t);
            }
        };
    }
}

封装ThreadPoolTaskExecutor线程池

1、新增application.yml配置

这里主要是配置ThreadPoolTastExecutor比较重要的参数

thread:
  poolexecutor:
    corePoolSize: 10 # 核心线程数量
    maxPoolSize: 30 # 最大线程数量
    queueCapacity: 100 # 队列长度
    keppAliveSeconds: 60 # 存活时间
    prefixName: "taskExecutor-" # 线程名称前缀

2、properties类

这个是为了简化代码，不用@Value一个一个去获取值

package com.walker.async.common.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@Data
@ConfigurationProperties(prefix = "thread.poolexecutor")
public class ThreadPoolProperties {
    private Integer corePoolSize;
    private Integer maxPoolSize;
    private Integer queueCapacity;
    private Integer keppAliveSeconds;
    private String prefixName;
}

3、配置类

配置线程池，并将其注入到bean中

package com.walker.async.common.config;

import com.walker.async.common.properties.ThreadPoolProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

//开启异步
@EnableAsync
//配置类
@Configuration
public class ThreadPoolConfig {
    @Autowired
    private ThreadPoolProperties threadPoolProperties;

    //bean名称
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        executor.setKeepAliveSeconds(threadPoolProperties.getKeppAliveSeconds());
        executor.setThreadNamePrefix(threadPoolProperties.getPrefixName());
        //设置线程池关闭的时候 等待所有的任务完成后再继续销毁其他的bean
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

4、封装Service和service实现类,方便管理

package com.walker.async.service.async;

public interface TestAsync {

    void doAsync();
}
package com.walker.async.service.async.impl;

import com.walker.async.service.async.TestAsync;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class TestAsyncImpl implements TestAsync {


    @Override
    //使用@Async，并将前面的注册的bean，填写到Async的value中
    @Async("taskExecutor")
    public void doAsync() {
        log.info("== async start==");
        log.info("线程{}执行代码逻辑",Thread.currentThread().getName());
        log.info("== async end==");
    }
}

5、测试

package com.walker.async;

import com.walker.async.service.async.TestAsync;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AsyncTest {
    //引用类
    @Autowired
    private TestAsync testAsync;

    @Test
    void test(){
        for (int i = 0; i < 10; i++) {
            testAsync.doAsync();
        }

    }
}

返回结果：

2023-01-29 16:47:12.491  INFO 13332 --- [ taskExecutor-2] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.491  INFO 13332 --- [ taskExecutor-1] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.493  INFO 13332 --- [ taskExecutor-4] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.493  INFO 13332 --- [ taskExecutor-3] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.493  INFO 13332 --- [ taskExecutor-5] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.501  INFO 13332 --- [ taskExecutor-9] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.501  INFO 13332 --- [taskExecutor-10] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.500  INFO 13332 --- [ taskExecutor-7] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.502  INFO 13332 --- [ taskExecutor-8] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.500  INFO 13332 --- [ taskExecutor-6] c.w.a.service.async.impl.TestAsyncImpl   : == async start==
2023-01-29 16:47:12.502  INFO 13332 --- [ taskExecutor-6] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-6执行代码逻辑
2023-01-29 16:47:12.501  INFO 13332 --- [ taskExecutor-5] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-5执行代码逻辑
2023-01-29 16:47:12.503  INFO 13332 --- [ taskExecutor-5] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.492  INFO 13332 --- [ taskExecutor-2] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-2执行代码逻辑
2023-01-29 16:47:12.503  INFO 13332 --- [ taskExecutor-2] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.503  INFO 13332 --- [ taskExecutor-6] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.501  INFO 13332 --- [ taskExecutor-9] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-9执行代码逻辑
2023-01-29 16:47:12.492  INFO 13332 --- [ taskExecutor-1] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-1执行代码逻辑
2023-01-29 16:47:12.506  INFO 13332 --- [ taskExecutor-1] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.506  INFO 13332 --- [ taskExecutor-9] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.493  INFO 13332 --- [ taskExecutor-3] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-3执行代码逻辑
2023-01-29 16:47:12.501  INFO 13332 --- [taskExecutor-10] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-10执行代码逻辑
2023-01-29 16:47:12.506  INFO 13332 --- [ taskExecutor-3] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.506  INFO 13332 --- [taskExecutor-10] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.502  INFO 13332 --- [ taskExecutor-8] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-8执行代码逻辑
2023-01-29 16:47:12.506  INFO 13332 --- [ taskExecutor-8] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.502  INFO 13332 --- [ taskExecutor-7] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-7执行代码逻辑
2023-01-29 16:47:12.508  INFO 13332 --- [ taskExecutor-7] c.w.a.service.async.impl.TestAsyncImpl   : == async end==
2023-01-29 16:47:12.493  INFO 13332 --- [ taskExecutor-4] c.w.a.service.async.impl.TestAsyncImpl   : 线程taskExecutor-4执行代码逻辑
2023-01-29 16:47:12.508  INFO 13332 --- [ taskExecutor-4] c.w.a.service.async.impl.TestAsyncImpl   : == async end==

可以发现，该方法使用了线程池.

6、打印线程池情况（自主选择）

  • 编写ThreadPoolTaskExecutor继承类
package com.walker.async.common.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
//1、继承ThreadPoolTaskExecutor
public class VisibleThreadPoolTaskExecutor extends ThreadPoolTaskExecutor  {

    
    //2、编写打印线程池方法
    private void log(String method){
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        if(threadPoolExecutor==null){
            return;
        }

        log.info("线程池：{}, 执行方法：{},任务数量 [{}], 完成任务数量 [{}], 活跃线程数 [{}], 队列长度 [{}]",
                this.getThreadNamePrefix(),
                method,
                threadPoolExecutor.getTaskCount(),
                threadPoolExecutor.getCompletedTaskCount(),
                threadPoolExecutor.getActiveCount(),
                threadPoolExecutor.getQueue().size());
    }


    
    //3、重写方法，进行日志的记录
    @Override
    public void execute(Runnable task) {
        log("execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        log("execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        log("submit");
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        log("submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        log("submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        log("submitListenable");
        return super.submitListenable(task);
    }
}
  • 重新编写线程池配置类
package com.walker.async.common.config;

import com.walker.async.common.properties.ThreadPoolProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@EnableAsync
@Configuration
public class ThreadPoolConfig {
    @Autowired
    private ThreadPoolProperties threadPoolProperties;

    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        executor.setKeepAliveSeconds(threadPoolProperties.getKeppAliveSeconds());
        executor.setThreadNamePrefix(threadPoolProperties.getPrefixName());
        //设置线程池关闭的时候 等待所有的任务完成后再继续销毁其他的bean
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }


    
    @Bean("visibleTaskExecutor")
    public Executor visible() {

        //1、使用VisibleThreadPoolTaskExecutor作为类
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        executor.setKeepAliveSeconds(threadPoolProperties.getKeppAliveSeconds());
        executor.setThreadNamePrefix(threadPoolProperties.getPrefixName());
        //设置线程池关闭的时候 等待所有的任务完成后再继续销毁其他的bean
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}
  • service和实现类也重新编写
void visibleAsync();
    /**
    * 可视化，可以打印线程池情况
    */
    @Override
    @Async("visibleTaskExecutor")
    public void visibleAsync() {
        log.info("== async start==");
        log.info("线程{}执行代码逻辑",Thread.currentThread().getName());
        log.info("== async end==");
    }
  • 测试
package com.walker.async;

import com.walker.async.service.async.TestAsync;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AsyncTest {
    @Autowired
    private TestAsync testAsync;


    @Test
    void test(){
        for (int i = 0; i < 10; i++) {
//            testAsync.doAsync();
            testAsync.visibleAsync();
        }
    }
}
  • 返回结果

image-20230313214251731

每次执行的时候，都会打印对应的线程池情况了

基于SpringBoot的多线程实现快速导入EXCEL
LEN程序员的一生
04-19 7186
前言：笔者已经做过多个版本的EXCEL导入功能。此次出一版基于SpringBoot的多线程实现快速导入EXCEL，效率之高体现在速度之快，单次解析的数据量之大。对比如下：第一版：导入5万条数据，花费近一个时第二版：导入10万条数据，花费23分钟，优化后达到了15分钟。第三版：导入112400条数据，花费3秒钟，极限是15万。数据再增大将会造成内存溢出。第三版：采用了多线程 1、不分服务，导入100万条数据，花费30秒之内。2、分服务，速度有所下降，80秒之内。效果图如下：注：导入数据速度跟数“量”的大小有关
SpringBoot整合MybatisPlus多线程下切换数据源的设计方案
数据与算法架构提升之路专栏
09-19 475
大数据项目经常同一个项目里会有涉及多数源的场景
Spring boot多线程配置方法
08-28
主要为大家详细介绍了Spring boot多线程配置方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
juc并发编程第一部分
qq_42732912的博客
04-27 2470
前言：文中出现的示例代码地址为：gitee代码地址 线程与进程 2.1 进程与进程 进程 程序由指令和数据组成，但是这些指令要运行，数据要读写，就必须将指令加载到cpu，数据加载至内存。在指令运行过程中还需要用到磁盘，网络等设备，进程就是用来加载指令管理内存管理IO的 当一个指令被运行，从磁盘加载这个程序的代码到内存，这时候就开启了一个进程 进程就可以视为程序的一个实例，大部分程序都可以运行多个实例进程（例如记事本，浏览器等），部分只可以运行一个实例进程（例如360安全卫士） 线程 一个进程之内可以分
Spring Boot多线程使用方式详解（附实战代码）
最新发布
danny-IT技术博客
03-28 901
/ getter@Async + 自定义线程池开发效率高：通过注解即可实现异步维护方便：线程池参数集中管理适用性广：覆盖80%的异步场景需求// 典型业务场景：用户注册后异步执行// 记录日志// 发送邮件// 发放优惠券通过合理使用多线程，可以显著提升Spring Boot应用的吞吐量和响应速度，但务必注意线程安全和资源管理！
springboot中多线程的使用
qq_36996785的博客
07-14 3540
程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。
SpringBoot整合多线程
weixin_40911000的博客
09-12 469
1.编写配置类 package com.cc.myall.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.task.TaskExecutor; import org.springframework.scheduling.annotation.Enabl
spring boot 集成多线程
alantuling_jt的博客
10-26 5189
线程池的配置文件新建配置文件application.yml 添加内容#线程池配置 spring: task: pool: corePoolSize : 4 maxPoolSize : 8 keepAliveSeconds : 60 queueCapacity : 20新建线程池参数装载类@ConfigurationProperties(p
springboot整合多线程ThreadPoolTaskExecutor
周不老的博客
10-22 1054
springboot整合多线程 springboot整合ThreadPoolTaskExecutor实现多线程 处理一些高并发需要使用多线程。可根据自己项目需求配置ThreadPoolTaskExecutor的参数 目录结构 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/X
八、SpringBoot整合多线程异步
qq23001186的博客
03-23 1058
目录前言一、异步调用实现二、@Async整合线程池 前言 @Async实际就是多线程封装的 异步线程执行方法有可能会非常消耗cpu的资源，所以大的项目建议使用Mq异步实现 一、异步调用实现 1.启动类需要添加注解@EnableAsync @SpringBootApplication @EnableAsync public class App { public static void main(String[] args) { SpringApplication.run(App
SpringBoot整合多线程异步
qq_45860824的博客
11-26 600
整合多线程异步异步调用使用@Async实现异步调用@Async失效问题使用@Async整合线程池 异步调用 单线程情况下，接口响应给客户端时间变慢 ，异步线程会单独开启一个线程，提高响应效率。 创建类 @RequestMapping("/add") public String add(){ log.info(">01<"); sms(); log.info(">04<"); return "用户注册成功"; }
Spring Boot多线程demo
12-16
springboot多线程范例，Spring Boot中使用多线程的方式有很多种，最简单的方式就是使用@Async注解来实现。
Springboot Druid多数据源 多线程
05-14
一个基于Springboot的小项目，采用Druid多数据源的设计，可以同时操作Mysql与Oracle数据库，配置了多线程处理任务，为刚接触springboot的朋友提供参考。
springboot如何集成多线程开发
1687F
08-29 189
Spring Boot是一个非常强大的框架，它可以简化Spring应用程序的初始设置和开发过程。Spring Boot默认使用了Java的Executor来处理多线程任务。以上就是在Spring Boot中集成多线程开发的基本步骤。请注意，多线程编程是一个复杂的主题，你需要理解并发和线程安全的概念，以避免出现潜在的问题。现在，你可以在任何需要的地方使用你的线程池执行器了。例如，你可以在服务层或者控制器层使用它。如果你使用的是Spring Boot版本2.x，那么这个依赖应该已经包含在内。
Springboot 整合多线程示例（简单易懂）
热门推荐
qq_38736877的博客
09-16 1万+
在之前的示例里我们实现了读取路径下所有csv文件，将其中数据转化为json对象并另存为json文件的功能。但是，在之前的代码中，我们是以顺序处理的方式依次处理csv文件的，只有在一个文件处理完之后才能开始处理下一个文件，总处理时间为所有文件处理时间之和，当文件数据量较大时会花费很长时间；所以，在这里我们引入多线程处理方法，让多个文件同时进行处理，这样总处理时间会大大减少。 Springboot读取.csv文件并转化为JSON对象 一. 多线程引入 1. 配置线程池 package com.exa.
【Spring】SpringBoot整合ShardingSphere并实现多线程分批插入10000条数据（进行分库分表操作）。
qq_61024956的博客
04-03 4394
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。ShardingSphere定位为关系型数据库中间件，旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。
springboot集成多线程
足迹
07-26 994
在springboot项目中集多线程 1.首先在项目启动类中加入设置线程基本配置项 //多线程配置 @EnableAsync @Configuration class TaskPoolConfig { @Bean("NetmarchThread") public Executor taskExecutor() { ...
springboot集成多线程功能
随我的博客
08-13 4989
参考文章 https://segmentfault.com/a/1190000015766938 https://blog.youkuaiyun.com/qq_34545192/article/details/80484780 在平时我们写多线程可能更多是使用new Thread() 或者创建线程池来实现的，但是在阿里的java开发规范中要求不要自己直接创建新线程，而是通过线程池来实现的，恰好spring ...
springboot整合mqtt 多线程
12-29
### Spring Boot 中 MQTT 协议集成与多线程处理 在现代分布式应用开发中，消息队列扮演着至关重要的角色。对于物联网(IoT)场景下的数据传输需求而言，采用轻量级的消息协议如MQTT显得尤为重要[^1]。 #### 一、依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值