Spring Boot 定时任务的多种实现方式

🌟 前言

欢迎来到我的技术小宇宙！🌌 这里不仅是我记录技术点滴的后花园，也是我分享学习心得和项目经验的乐园。📚 无论你是技术小白还是资深大牛，这里总有一些内容能触动你的好奇心。🔍

  • 🤖 洛可可白：个人主页

  • 🔥 个人专栏：✅前端技术 ✅后端技术

  • 🏠 个人博客：洛可可白博客

  • 🐱 代码获取：bestwishes0203

  • 📷 封面壁纸：洛可可白wallpaper

在这里插入图片描述

这里写自定义目录标题

  • Spring Boot 定时任务的多种实现方式
    • 1. 使用 `@Scheduled` 注解
      • 示例代码
      • 优点
      • 缺点
    • 2. 使用 `ScheduledExecutorService`
      • 示例代码
      • 优点
      • 缺点
    • 3. 使用 Quartz 框架
      • 示例代码
      • 优点
      • 缺点
    • 4. 使用 `SchedulingConfigurer` 接口
      • 示例代码
      • 优点
      • 缺点
    • 5. 使用 `TaskScheduler` 接口
      • 示例代码
      • 优点
      • 缺点
    • 6. 使用 Redis 实现分布式定时任务
      • 示例代码
      • 优点
      • 缺点
    • 7. 使用 XXL-JOB 或 Elastic-Job
      • 示例代码（XXL-JOB）
      • 优点
      • 缺点
    • 总结
    • 选择合适的定时任务实现方式
    • 示例项目结构
    • 示例代码完整版
      • `DemoApplication.java`
      • `SchedulingConfig.java`
      • `ScheduledTask.java`
      • `RedisConfig.java`
      • `RedisDistributedTask.java`
      • `application.properties`
    • 结语

Spring Boot 定时任务的多种实现方式

在现代的 Spring Boot 应用程序中，定时任务是一种常见的需求。无论是定期清理日志、同步数据，还是执行定时的业务逻辑，Spring Boot 提供了多种灵活的方式来实现定时任务。本文将详细介绍几种常见的定时任务实现方式，并通过示例代码帮助你快速上手。

1. 使用 @Scheduled 注解

@Scheduled 是 Spring Boot 提供的一种简单且强大的定时任务实现方式，适用于大多数简单的定时任务场景。

示例代码

配置类：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;@Configuration
@EnableScheduling
public class SchedulingConfig {// 启用定时任务支持
}

任务类：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;@Component
public class ScheduledTask {// 固定频率：每5秒执行一次任务@Scheduled(fixedRate = 5000)public void executeTask() {System.out.println("【@Scheduled 任务】执行时间：" + LocalDateTime.now());}// Cron 表达式：每天中午12点执行一次任务@Scheduled(cron = "0 0 12 * * ?")public void executeCronTask() {System.out.println("【Cron 任务】执行时间：" + LocalDateTime.now());}
}

优点

  • 简单易用：只需添加注解即可实现定时任务。
  • 集成度高：与 Spring 容器无缝集成，支持依赖注入。

缺点

  • 单节点运行：默认情况下，@Scheduled 任务仅在单个节点上运行，不支持分布式场景。

2. 使用 ScheduledExecutorService

ScheduledExecutorService 是 Java 提供的原生定时任务工具，适合需要更细粒度控制的任务调度场景。

示例代码

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledExecutorServiceExample {public static void main(String[] args) {ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);executor.scheduleAtFixedRate(() -> {System.out.println("任务执行：" + System.currentTimeMillis());}, 0, 5, TimeUnit.SECONDS);}
}

优点

  • 灵活性高：可以自定义线程池大小和任务执行策略。
  • 独立性强：不依赖于 Spring 框架，适合非 Spring 环境。

缺点

  • 功能有限：不支持复杂的时间调度策略，如 Cron 表达式。

3. 使用 Quartz 框架

Quartz 是一个功能强大的任务调度框架，支持复杂的调度任务，例如动态任务配置和分布式任务调度。

示例代码

依赖：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

任务类：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;public class MyJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Quartz 任务执行：" + System.currentTimeMillis());}
}

配置类：

import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class QuartzConfig {@Beanpublic JobDetail jobDetail() {return JobBuilder.newJob(MyJob.class).withIdentity("myJob").storeDurably().build();}@Beanpublic Trigger jobTrigger(JobDetail jobDetail) {return TriggerBuilder.newTrigger().forJob(jobDetail).withIdentity("myTrigger").withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever()).build();}
}

优点

  • 功能强大：支持复杂的调度策略，如动态任务配置和分布式任务调度。
  • 高可靠性：支持任务持久化和恢复。

缺点

  • 配置复杂：需要额外的配置和依赖。
  • 学习曲线：相比 @Scheduled，Quartz 的学习成本较高。

4. 使用 SchedulingConfigurer 接口

SchedulingConfigurer 是 Spring 提供的一个接口，允许动态配置定时任务，例如从数据库中读取任务配置。

示例代码

import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.Date;@Configuration
public class DynamicSchedulingConfig implements SchedulingConfigurer {@Overridepublic void configureTasks(ScheduledTaskRegistrar taskRegistrar) {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(10);executor.initialize();taskRegistrar.setTaskExecutor(executor);taskRegistrar.addTriggerTask(() -> System.out.println("动态任务执行：" + new Date()),new Trigger() {@Overridepublic Date nextExecutionTime(TriggerContext triggerContext) {return new CronTrigger("0/5 * * * * ?").nextExecutionTime(triggerContext);}});}
}

优点

  • 动态配置：支持从外部动态加载任务配置。
  • 灵活性高：可以结合数据库或其他存储实现动态任务管理。

缺点

  • 复杂度高：实现动态任务配置需要额外的开发工作。

5. 使用 TaskScheduler 接口

TaskScheduler 是 Spring 提供的一个接口，支持动态任务调度，适合需要动态调整任务执行频率的场景。

示例代码

import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.Date;@Configuration
@EnableScheduling
public class TaskSchedulerConfig implements SchedulingConfigurer {@Overridepublic void configureTasks(ScheduledTaskRegistrar taskRegistrar) {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(10);executor.initialize();taskRegistrar.setTaskExecutor(executor);taskRegistrar.addFixedRateTask(() -> System.out.println("固定频率任务执行：" + new Date()), 5000);}
}

优点

  • 动态调度：支持动态调整任务执行频率。
  • 简单易用：与 Spring 容器无缝集成。

缺点

  • 功能有限：不支持复杂的时间调度策略。

6. 使用 Redis 实现分布式定时任务

Redis 是一个高性能的键值存储系统，可以利用其特性实现简单的分布式定时任务。

示例代码

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;@Component
public class RedisDistributedTask {private final RedisTemplate<String, String> redisTemplate;public RedisDistributedTask(RedisTemplate<String, String> redisTemplate) {this.redisTemplate = redisTemplate;}@Scheduled(fixedRate = 5000)public void executeTask() {String lockKey = "distributedTaskLock";String lockValue = String.valueOf(System.currentTimeMillis());Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, 5, TimeUnit.SECONDS);if (lock != null && lock) {System.out.println("分布式任务执行：" + new Date());}}
}

优点

  • 分布式支持：可以实现简单的分布式任务调度。
  • 简单易用：基于 Redis 的特性，实现简单。

缺点

  • 功能有限：不支持复杂的调度策略。

7. 使用 XXL-JOB 或 Elastic-Job

XXL-JOB 和 Elastic-Job 是轻量级的分布式任务调度平台，支持动态任务管理和高可用性。

示例代码（XXL-JOB）

依赖：

<dependency><groupId>com.xuxueli</groupId><artifactId>xxl-job-core</artifactId><version>3.1.2</version>
</dependency>

任务类：

import com.xxl.job.core.handler.annotation.XxlJob;
import org.springframework.stereotype.Component;@Component
public class XxlJobExample {@XxlJob("myJobHandler")public void myJobHandler() {System.out.println("XXL-JOB 任务执行：" + System.currentTimeMillis());}
}

配置类（XXL-JOB）

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class XxlJobConfig {@Beanpublic XxlJobSpringExecutor xxlJobExecutor() {XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();xxlJobSpringExecutor.setAdminAddresses("http://127.0.0.1:8080/xxl-job-admin");xxlJobSpringExecutor.setAppname("xxl-job-executor-sample");xxlJobSpringExecutor.setIp("127.0.0.1");xxlJobSpringExecutor.setPort(9999);return xxlJobSpringExecutor;}
}

优点

  • 功能强大：支持动态任务管理、分布式任务调度、任务监控等功能。
  • 高可用性：支持任务的容错和恢复机制。
  • 易于集成：与 Spring Boot 集成简单，配置方便。

缺点

  • 学习成本：需要额外学习 XXL-JOB 或 Elastic-Job 的使用方式。
  • 依赖外部系统：需要部署额外的调度中心（如 XXL-JOB 的管理平台）。

总结

在 Spring Boot 中，有多种方式可以实现定时任务，每种方式都有其适用场景和优缺点：

实现方式优点缺点适用场景
@Scheduled 注解简单易用，与 Spring 集成度高不支持分布式任务单节点应用，简单任务调度
ScheduledExecutorService灵活性高，适合复杂任务调度不支持复杂的时间调度策略需要自定义线程池的任务调度
Quartz 框架功能强大，支持复杂调度策略和分布式任务配置复杂，学习成本高需要复杂调度策略的应用
SchedulingConfigurer 接口支持动态任务配置实现复杂，需要额外开发工作动态任务配置需求
TaskScheduler 接口动态调度，与 Spring 集成度高功能有限，不支持复杂调度策略动态调整任务执行频率的场景
Redis 分布式任务支持分布式任务调度，实现简单功能有限，不支持复杂调度策略分布式任务调度，简单场景
XXL-JOB / Elastic-Job功能强大，支持动态任务管理和高可用性需要额外部署调度中心，学习成本高分布式任务调度，复杂场景

选择合适的定时任务实现方式

选择哪种定时任务实现方式取决于你的具体需求：

  1. 简单任务调度：如果任务逻辑简单，且仅在单个节点上运行，推荐使用 @Scheduled 注解。
  2. 复杂任务调度：如果需要支持复杂的时间调度策略（如 Cron 表达式），或者需要分布式任务调度，可以考虑使用 Quartz 框架。
  3. 动态任务配置：如果任务配置需要动态加载（如从数据库中读取），可以使用 SchedulingConfigurer 接口。
  4. 分布式任务调度：如果需要在多个节点上运行任务，且任务调度需要高可用性，推荐使用 XXL-JOB 或 Elastic-Job。
  5. 轻量级任务调度：如果需要快速实现简单的分布式任务调度，可以考虑使用 Redis。

示例项目结构

以下是一个简单的 Spring Boot 项目结构，展示了如何集成 @Scheduled 和 Redis 分布式任务：

my-spring-boot-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── com.example.demo/
│   │   │   │   ├── application/
│   │   │   │   │   ├── DemoApplication.java
│   │   │   │   ├── config/
│   │   │   │   │   ├── SchedulingConfig.java
│   │   │   │   │   ├── RedisConfig.java
│   │   │   │   ├── service/
│   │   │   │   │   ├── ScheduledTask.java
│   │   │   │   │   ├── RedisDistributedTask.java
│   │   │   │   ├── model/
│   │   │   │   ├── controller/
│   │   │   │   ├── repository/
│   │   │   │   ├── util/
│   │   │   ├── resources/
│   │   │   │   ├── application.properties
│   │   │   │   ├── static/
│   │   │   │   ├── templates/
│   │   ├── test/
│   │   │   ├── java/
│   │   │   │   ├── com.example.demo/
│   │   │   │   │   ├── DemoApplicationTests.java
│   │   │   ├── resources/
│   ├── pom.xml

示例代码完整版

DemoApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class DemoApplication {public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args);}
}

SchedulingConfig.java

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;@Configuration
@EnableScheduling
public class SchedulingConfig {// 启用定时任务支持
}

ScheduledTask.java

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;@Component
public class ScheduledTask {// 固定频率：每5秒执行一次任务@Scheduled(fixedRate = 5000)public void executeTask() {System.out.println("【@Scheduled 任务】执行时间：" + LocalDateTime.now());}// Cron 表达式：每天中午12点执行一次任务@Scheduled(cron = "0 0 12 * * ?")public void executeCronTask() {System.out.println("【Cron 任务】执行时间：" + LocalDateTime.now());}
}

RedisConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;@Configuration
public class RedisConfig {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(redisConnectionFactory);// 设置 Key 的序列化器template.setKeySerializer(new StringRedisSerializer());template.setHashKeySerializer(new StringRedisSerializer());// 设置 Value 的序列化器template.setValueSerializer(new GenericJackson2JsonRedisSerializer());template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());template.afterPropertiesSet();return template;}
}

RedisDistributedTask.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;import java.util.Date;@Component
public class RedisDistributedTask {private final RedisTemplate<String, String> redisTemplate;@Autowiredpublic RedisDistributedTask(RedisTemplate<String, String> redisTemplate) {this.redisTemplate = redisTemplate;}@Scheduled(fixedRate = 5000)public void executeTask() {String lockKey = "distributedTaskLock";String lockValue = String.valueOf(System.currentTimeMillis());Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, 5, TimeUnit.SECONDS);if (lock != null && lock) {System.out.println("分布式任务执行：" + new Date());}}
}

application.properties

# Redis 配置
spring.data.redis.host=localhost
spring.data.redis.port=6379
spring.data.redis.password=

结语

通过本文的介绍，你应该对 Spring Boot 中的定时任务实现方式有了更全面的了解。无论是简单的单节点任务，还是复杂的分布式任务，Spring Boot 都提供了灵活的解决方案。希望这些示例代码能帮助你快速实现定时任务的需求。

如果你有任何问题或建议，欢迎在评论区留言。

如果对你有帮助，点赞👍、收藏💖、关注🔔是我更新的动力！👋🌟🚀

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/75460.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Java基础之反射的基本使用

Java基础之反射的基本使用

简介 在运行状态中&#xff0c;对于任意一个类&#xff0c;都能够知道这个类的所有属性和方法&#xff1b;对于任意一个对象&#xff0c;都能够调用它的任意属性和方法&#xff1b;这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。反射让Java成为了一门动…
阅读更多...
AI产品的上层建筑：提示词工程、RAG与Agent

AI产品的上层建筑：提示词工程、RAG与Agent

上节课我们拆解了 AI 产品的基础设施建设&#xff0c;这节课我们聊聊上层建筑。这部分是产品经理日常工作的重头戏&#xff0c;包含提示词、RAG 和 Agent 构建。 用 AI 客服产品举例&#xff0c;这三者的作用是这样的&#xff1a; 提示词能让客服很有礼貌。比如它会说&#x…
阅读更多...
蓝桥杯刷题记录【并查集001】（2024）

蓝桥杯刷题记录【并查集001】（2024）

主要内容&#xff1a;并查集 并查集 并查集的题目感觉大部分都是模板题&#xff0c;上板子&#xff01;&#xff01; class UnionFind:def __init__(self, n):self.pa list(range(n))self.size [1]*n self.cnt ndef find(self, x):if self.pa[x] ! x:self.pa[x] self.fi…
阅读更多...
海外SD-WAN专线网络部署成本分析

海外SD-WAN专线网络部署成本分析

作为支撑企业国际业务的重要基石&#xff0c;海外SD-WAN专线以其独特的成本优势和技术特性&#xff0c;正成为企业构建高效稳定的全球网络架构的首选方案。本文将从多维度解构海外SD-WAN专线部署的核心成本要素&#xff0c;为企业的全球化网络布局提供战略参考。 一、基础资源投…
阅读更多...
操作系统（二）：实时系统介绍与实例分析

操作系统（二）：实时系统介绍与实例分析

目录 一.概念 1.1 分类 1.2 主要指标 二.实现原理 三.主流实时系统对比 一.概念 实时系统&#xff08;Real-Time System, RTS&#xff09;是一类以时间确定性为核心目标的计算机系统&#xff0c;其设计需确保在严格的时间约束内完成任务响应。 1.1 分类 根据时间约束的严…
阅读更多...
Golang的消息中间件选型

Golang的消息中间件选型

# Golang的消息中间件选型 消息中间件的作用 消息中间件是一种用于分布式系统中应用程序之间进行通信的基础架构工具&#xff0c;它能够有效地解耦发送者和接收者&#xff0c;并提供高可用性和可靠性的消息传递机制。在Golang应用程序中&#xff0c;选择适合的消息中间件对于构…
阅读更多...
大模型中的参数规模与显卡匹配

大模型中的参数规模与显卡匹配

在大模型训练和推理中&#xff0c;显卡&#xff08;GPU/TPU&#xff09;的选择与模型参数量紧密相关&#xff0c;需综合考虑显存、计算能力和成本。以下是不同规模模型与硬件的匹配关系及优化策略&#xff1a; 一、参数规模与显卡匹配参考表 模型参数量训练阶段推荐显卡推理阶…
阅读更多...
带头结点 的单链表插入方法（头插法与尾插法）

带头结点 的单链表插入方法（头插法与尾插法）

带头结点的单链表插入方法&#xff08;头插法与尾插法&#xff09; 在单链表的操作中&#xff0c;插入是最常见的操作之一&#xff0c;本文介绍 带头结点的单链表 如何实现 后插法 和 前插法&#xff08;包括 插入法 和 后插数据交换法&#xff09;&#xff0c;并提供完整的 C …
阅读更多...
Prometheus的工作流程

Prometheus的工作流程

Prometheus 是一个开源的监控和告警系统&#xff0c;专为监控分布式系统而设计。它的工作流程主要包括以下几个关键步骤&#xff1a; 1. 数据采集 (Scraping) 目标发现 (Service Discovery)&#xff1a; Prometheus 自动或手动配置监控目标&#xff0c;通过 DNS、Kubernetes、…
阅读更多...
软件工程面试题（二十二）

软件工程面试题（二十二）

1、常用的设计模式有哪些&#xff1f;并写出一段程序代码 Factory(工厂模式)&#xff0c;Adapter(适配器模式)&#xff0c;Singleton(单例模式)&#xff0c;State(状态模式)&#xff0c;Observer(观察者模式) 等。 单例模式 public class Singleton{ private static Singleton …
阅读更多...
【Pandas】pandas DataFrame select_dtypes

【Pandas】pandas DataFrame select_dtypes

Pandas2.2 DataFrame Attributes and underlying data 方法描述DataFrame.index用于获取 DataFrame 的行索引DataFrame.columns用于获取 DataFrame 的列标签DataFrame.dtypes用于获取 DataFrame 中每一列的数据类型DataFrame.info([verbose, buf, max_cols, …])用于提供 Dat…
阅读更多...
如何利用ATECLOUD测试平台的芯片测试解决方案实现4644芯片的测试？

如何利用ATECLOUD测试平台的芯片测试解决方案实现4644芯片的测试？

作为多通道 DC-DC 电源管理芯片的代表产品&#xff0c;4644 凭借 95% 以上的转换效率、1% 的输出精度及多重保护机制&#xff0c;广泛应用于航天航空&#xff08;卫星电源系统&#xff09;、医疗设备&#xff08;MRI 梯度功放&#xff09;、工业控制&#xff08;伺服驱动单元&a…
阅读更多...
Python 编程实战：打造高效便捷的目录结构生成器

Python 编程实战：打造高效便捷的目录结构生成器

Python 编程实战&#xff1a;打造高效便捷的目录结构生成器 相关资源文件已经打包成EXE文件&#xff0c;可双击直接运行程序&#xff0c;且文章末尾已附上相关源码&#xff0c;以供大家学习交流&#xff0c;博主主页还有更多Python相关程序案例&#xff0c;秉着开源精神的想法&…
阅读更多...
移动端六大语言速记：第6部分 - 错误处理与调试

移动端六大语言速记：第6部分 - 错误处理与调试

移动端六大语言速记：第6部分 - 错误处理与调试 本文将对比Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言在错误处理与调试方面的特性，帮助开发者理解和掌握各语言的异常处理机制。 6. 错误处理与调试 6.1 异常处理 各语言异常处理的语法对比：…
阅读更多...
PyTorch优化器

PyTorch优化器

PyTorch 提供了多种优化算法用于神经网络的参数优化。以下是对 PyTorch 中主要优化器的全面介绍&#xff0c;包括它们的原理、使用方法和适用场景。 一、基本优化器 1. SGD (随机梯度下降) torch.optim.SGD(params, lr0.01, momentum0, dampening0, weight_decay0, nesterov…
阅读更多...
C++的UDP连接解析域名地址错误

C++的UDP连接解析域名地址错误

背景 使用c开发一个udp连接功能的脚本&#xff0c;可以接收发送数据&#xff0c;而且地址是经过内网穿透到外网的 经过 通常发送数据给目标地址&#xff0c;需要把目的地址结构化&#xff0c;要么使用inet_addr解析ip地址&#xff0c;要么使用inet_pton sockaddr_in target…
阅读更多...
Spark，上传文件

Spark，上传文件

上传文件 1.上传 先使用命令打开HDFS的NameNode [roothadoop100 hadoop-3.1.3]$ sbin/start-dfs.sh [roothadoop100 hadoop-3.1.3]$ sbin/stop-dfs.sh 和YARN的Job [roothadoop101 hadoop-3.1.3]$ sbin/start-yarn.sh [roothadoop101 hadoop-3.1.3]$ sbin/stop-yarn.sh 在Nam…
阅读更多...
如何为Linux/Android Kernel 5.4和5.15添加 fuse passthrough透传功能 ?

如何为Linux/Android Kernel 5.4和5.15添加 fuse passthrough透传功能 ?

背景 参考&#xff1a;Google文档 FUSE 透传 参考此文档&#xff0c;目前kernel.org提供的fuse passthrough补丁在6.9版本之后&#xff0c;但想要在5.4和5.15版本内核做移植应该如何简单点呢&#xff1f;文档中提到 Android的内核为5.4 和 5.15版本内核做了fuse passthrough功…
阅读更多...
Ubuntu 防火墙配置

Ubuntu 防火墙配置

Ubuntu 的防火墙配置可以参考文章&#xff1a;Firewall - Ubuntu Server documentation 22 端口 需要注意的是&#xff0c;在启动防火墙之前&#xff0c;需要先开放 22 端口。 否则 SSH 将会拒绝你连接防火墙。 开放 22 端口的命令为&#xff1a;sudo ufw allow 22 添加端…
阅读更多...
Jetson 设备卸载 OpenCV 4.5.4 并编译安装 OpenCV 4.2.0

Jetson 设备卸载 OpenCV 4.5.4 并编译安装 OpenCV 4.2.0

‌一、卸载 OpenCV 4.5.4‌ 清除已安装的 OpenCV 库‌ sudo apt-get purge libopencv* python3-opencv # 卸载所有APT安装的OpenCV包‌:ml-citation{ref"1,3" data"citationList"}sudo apt autoremove # 清理残留依赖‌:ml-citation{ref"1,4"…
阅读更多...
最新文章

Copyright @ 2022~2023