定时任务实战指南：从单机到分布式，覆盖Spring Scheduler/Quartz/XXL-Jo

回家路上绕了弯2026-01-08 15:55

定时任务实战指南：从单机到分布式，覆盖Spring Scheduler/Quartz/XXL-Job

在后端开发中，定时任务是不可或缺的核心组件------数据定时清理、每日报表生成、定时推送通知、订单超时关闭等场景，都离不开定时任务的支持。但实际开发中，很多开发者只停留在"能用"的层面，面对"任务并发冲突""分布式部署重复执行""任务监控告警"等问题时束手无策。今天，我们从基础到进阶，全面讲解定时任务的实现方案、实战技巧与避坑指南，覆盖单机到分布式的全场景需求。

一、先搞懂：定时任务的核心价值与应用场景

定时任务本质是"按预设时间规则自动执行的代码逻辑"，其核心价值在于"解放人工、保障业务定时闭环"。常见应用场景可分为5类：

  • 数据治理类：每日凌晨清理过期日志、无效订单；定期归档历史数据（如将3个月前的订单数据迁移至历史库）；
  • 业务闭环类：订单创建后30分钟未支付自动关闭；会员到期前3天发送续费提醒；
  • 统计报表类：每日凌晨生成前一天的销售报表、用户活跃报表；每月生成月度经营分析报告；
  • 系统运维类：定时检查服务健康状态；定期备份数据库；清理缓存碎片；
  • 消息推送类：定时推送每日早安消息、营销活动通知；定时同步第三方数据（如同步物流信息）。

不同场景对定时任务的要求不同：简单场景只需"按时执行"，复杂场景则需要考虑"高可用、无重复、可监控、可重试"。

二、定时任务的3种核心实现方案：选型对比

后端定时任务的实现方案有很多，从简单到复杂可分为3个层级，不同方案适配不同的业务规模：

实现方案 核心优势 局限性 适用场景
Spring Scheduler（@Scheduled） 1. 零依赖，Spring Boot原生支持；2. 配置简单，注解式开发；3. 轻量高效，无额外部署成本 1. 不支持分布式部署（易重复执行）；2. 无内置监控、重试机制；3. 任务依赖、动态调整能力弱 单机部署、简单定时任务（如单机服务的日志清理）
Quartz 1. 功能强大，支持复杂调度规则（如日历式调度）；2. 支持持久化（任务信息存入数据库）；3. 支持集群部署（解决重复执行）；4. 支持任务优先级、重试 1. 配置复杂，代码侵入性较强；2. 无内置监控告警，需自行实现；3. 分布式场景下运维成本较高 单机/集群部署、复杂调度规则的任务（如按工作日执行、任务依赖）
XXL-Job（分布式任务调度平台） 1. 分布式部署无重复执行；2. 内置Web管理界面（任务配置、执行日志、监控告警）；3. 支持动态调整任务、失败重试、任务依赖；4. 支持分片执行（大数据量处理） 1. 需额外部署调度中心；2. 轻度依赖中间件（MySQL）；3. 简单场景略显重量级 分布式微服务架构、高可用要求高的核心业务任务（如订单超时关闭、报表生成）

选型建议： 1. 简单场景（单机）：优先用 Spring Scheduler，快速落地无成本； 2. 复杂调度（单机/小规模集群）：用 Quartz，兼顾功能与稳定性； 3. 分布式微服务（大规模、高可用）：用 XXL-Job，解放运维与开发效率。

三、实战：3种方案的Spring Boot落地实现

下面结合Spring Boot，分别实现3种方案的定时任务，覆盖从简单到复杂的全场景。

1. 方案一：Spring Scheduler（单机简单任务）

Spring Scheduler是Spring框架内置的定时任务组件，无需额外引入依赖，注解式开发即可快速实现。

（1）环境准备：启用定时任务

在Spring Boot主类上添加 @EnableScheduling 注解，启用定时任务功能：

typescript 复制代码 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling // 启用定时任务
public class TimedTaskDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(TimedTaskDemoApplication.class, args);
    }
}
（2）核心实现：@Scheduled注解使用

创建定时任务类，通过 @Scheduled 注解定义任务执行规则，支持3种常见时间配置：cron表达式、固定速率、固定延迟。

java 复制代码 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.UUID;

/**
 * Spring Scheduler 定时任务示例
 */
@Component
public class SimpleTimedTask {
    private final Logger log = LoggerFactory.getLogger(SimpleTimedTask.class);

    /**
     * 1. cron表达式：按指定时间执行（每天凌晨3点清理过期订单）
     * cron语法：秒 分 时 日 月 周 年（年可选）
     * 示例：0 0 3 * * ?  表示每天03:00:00执行
     */
    @Scheduled(cron = "0 0 3 * * ?")
    public void cleanExpiredOrder() {
        // 手动绑定requestId到MDC，便于日志追踪（参考之前MDC博客内容）
        String requestId = UUID.randomUUID().toString().replace("-", "");
        MDC.put("requestId", requestId);
        try {
            log.info("开始清理过期订单");
            // 核心业务逻辑：删除创建时间超过30分钟且未支付的订单
            // orderMapper.deleteExpiredOrder(30); 
            log.info("过期订单清理完成");
        } catch (Exception e) {
            log.error("清理过期订单失败", e);
        } finally {
            MDC.clear(); // 清除MDC，避免线程复用污染
        }
    }

    /**
     * 2. 固定速率：按固定时间间隔执行（每隔5秒打印系统时间）
     * fixedRate：以上一次任务开始时间为基准，间隔固定时间执行
     */
    @Scheduled(fixedRate = 5000)
    public void printSystemTime() {
        log.info("当前系统时间：{}", System.currentTimeMillis());
    }

    /**
     * 3. 固定延迟：按固定延迟执行（上一次任务结束后，间隔固定时间再执行）
     * fixedDelay：适合任务执行时间不固定的场景（如数据同步，执行时间可能波动）
     */
    @Scheduled(fixedDelay = 10000)
    public void syncThirdPartyData() {
        log.info("开始同步第三方物流数据");
        try {
            // 模拟同步耗时（1-3秒）
            Thread.sleep((long) (Math.random() * 2000 + 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        log.info("第三方物流数据同步完成");
    }
}
（3）关键配置：自定义线程池

Spring Scheduler默认使用单线程执行所有定时任务，若多个任务同时触发，会导致任务阻塞（一个任务执行慢，后续任务排队）。建议自定义线程池，提高任务并发能力：

java 复制代码 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
@EnableAsync // 启用异步执行（可选，结合@Async使用）
public class SchedulerConfig {

    /**
     * 自定义定时任务线程池
     */
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5); // 核心线程数
        scheduler.setThreadNamePrefix("scheduler-thread-"); // 线程名前缀
        scheduler.setAwaitTerminationSeconds(60); // 等待任务执行完成的时间
        scheduler.setWaitForTasksToCompleteOnShutdown(true); // 关闭时等待任务完成
        scheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略（调用者执行，避免任务丢失）
        scheduler.initialize();
        return scheduler;
    }
}

2. 方案二：Quartz（复杂调度+集群部署）

Quartz是功能强大的开源定时任务框架，支持复杂调度规则、任务持久化和集群部署，适合需要"高可靠性"和"复杂调度"的场景。

（1）引入依赖
xml 复制代码 
<!-- Quartz核心依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

<!-- 数据库依赖（用于任务持久化） -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
（2）配置Quartz（application.yml）

配置Quartz的数据源（任务信息存入数据库）、线程池、集群模式：

yaml 复制代码 
spring:
  # 数据源配置（任务持久化到MySQL）
  datasource:
    url: jdbc:mysql://localhost:3306/quartz_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  # Quartz配置
  quartz:
    job-store-type: JDBC # 任务存储方式：JDBC（持久化）
    jdbc:
      initialize-schema: NEVER # 不自动初始化表结构（建议手动执行Quartz官方SQL）
    properties:
      org:
        quartz:
          scheduler:
            instanceName: quartzScheduler # 调度器实例名
            instanceId: AUTO # 实例ID自动生成（集群模式必须）
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10 # 线程池大小
            threadPriority: 5 # 线程优先级
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX # 事务型存储
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate # MySQL delegate
            tablePrefix: QRTZ_ # 表前缀（Quartz官方表的默认前缀）
            isClustered: true # 启用集群模式
            clusterCheckinInterval: 15000 # 集群节点心跳间隔（15秒）
            useProperties: false # 不使用属性文件存储任务参数
（3）实现Quartz任务（Job）

Quartz的任务需实现 Job 接口，重写 execute 方法：

java 复制代码 
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import java.util.UUID;

/**
 * Quartz任务：生成每日销售报表
 */
public class DailySalesReportJob implements Job {
    private final Logger log = LoggerFactory.getLogger(DailySalesReportJob.class);

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 绑定MDC链路标识
        String requestId = UUID.randomUUID().toString().replace("-", "");
        MDC.put("requestId", requestId);
        try {
            log.info("开始生成每日销售报表");
            // 核心业务逻辑：查询前一天的销售数据，生成Excel报表并存储
            // String reportPath = salesReportService.generateDailyReport();
            // log.info("每日销售报表生成完成，路径：{}", reportPath);
        } catch (Exception e) {
            log.error("生成每日销售报表失败", e);
            // 若任务失败，可抛出异常触发重试（需配置重试策略）
            throw new JobExecutionException("报表生成失败，触发重试", e, true);
        } finally {
            MDC.clear();
        }
    }
}
（4）配置任务触发器（Trigger）

通过配置类创建JobDetail和Trigger，定义任务执行规则：

kotlin 复制代码 
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzJobConfig {

    /**
     * 1. 定义JobDetail（任务详情）
     */
    @Bean
    public JobDetail dailySalesReportJobDetail() {
        return JobBuilder.newJob(DailySalesReportJob.class)
                .withIdentity("dailySalesReportJob", "reportGroup") // 任务标识（名称+组名）
                .storeDurably() // 任务即使没有触发器也持久化
                .build();
    }

    /**
     * 2. 定义Trigger（触发器）：每天凌晨2点执行
     */
    @Bean
    public Trigger dailySalesReportTrigger() {
        // 调度规则：每天02:00:00执行
        CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule("0 0 2 * * ?")
                .withMisfireHandlingInstructionDoNothing(); // 错过执行时间时，不执行（避免重复执行）

        return TriggerBuilder.newTrigger()
                .forJob(dailySalesReportJobDetail()) // 绑定任务
                .withIdentity("dailySalesReportTrigger", "reportGroup") // 触发器标识
                .withSchedule(cronSchedule) // 绑定调度规则
                .build();
    }
}

3. 方案三：XXL-Job（分布式任务调度平台）

XXL-Job是国内开源的分布式任务调度平台，基于"调度中心+执行器"架构，提供Web管理界面、任务监控、失败重试、分片执行等功能，是分布式微服务架构的首选方案。

（1）部署调度中心
  1. 从XXL-Job官网（www.xuxueli.com/xxl-job/）下载... doc/db/tables_xxl_job.sql SQL文件，创建调度中心数据库； 2. 修改调度中心配置文件（xxl-job-admin/src/main/resources/application.properties），配置数据库连接； 3. 启动调度中心（Spring Boot应用），访问 http://localhost:8080/xxl-job-admin，默认账号密码：admin/123456。
（2）集成执行器（Spring Boot项目）
① 引入依赖
xml 复制代码 
<!-- XXL-Job执行器依赖 -->
<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.4.0</version>
</dependency>
② 配置执行器（application.yml）
yaml 复制代码 
xxl:
  job:
    admin:
      addresses: http://localhost:8080/xxl-job-admin # 调度中心地址
    executor:
      appname: order-service-executor # 执行器名称（需在调度中心注册）
      address: "" # 执行器地址（空则自动注册）
      ip: "" # 执行器IP（空则自动获取）
      port: 9999 # 执行器端口
      logpath: ./logs/xxl-job/ # 任务日志路径
      logretentiondays: 30 # 日志保留天数
    accessToken: "" # 调度中心与执行器的通信令牌（空则关闭）
③ 配置执行器客户端
kotlin 复制代码 
import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        return xxlJobSpringExecutor;
    }
}
④ 实现XXL-Job任务

通过 @XxlJob 注解定义任务，任务逻辑写在注解指定的方法中：

java 复制代码 
import com.xxl.job.core.handler.annotation.XxlJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * XXL-Job任务：订单超时关闭
 */
@Component
public class OrderTimeoutCloseJob {
    private final Logger log = LoggerFactory.getLogger(OrderTimeoutCloseJob.class);

    /**
     * 任务标识：orderTimeoutCloseHandler（需在调度中心配置对应Handler名称）
     */
    @XxlJob("orderTimeoutCloseHandler")
    public void orderTimeoutClose() {
        log.info("开始执行订单超时关闭任务");
        try {
            // 核心业务逻辑：查询所有创建时间超过30分钟且未支付的订单，执行关闭操作
            // int closeCount = orderService.closeTimeoutOrder(30);
            // log.info("订单超时关闭任务执行完成，共关闭订单：{} 个", closeCount);
        } catch (Exception e) {
            log.error("订单超时关闭任务执行失败", e);
            // 抛出异常，XXL-Job会自动记录失败状态，支持手动重试或配置自动重试
            throw new RuntimeException("订单超时关闭失败", e);
        }
    }
}
⑤ 调度中心配置任务
  1. 登录XXL-Job管理界面，在"执行器管理"中添加执行器（AppName与配置文件一致）； 2. 在"任务管理"中创建任务： - 任务描述：订单超时关闭； - 执行器：选择已注册的执行器； - 任务类型：BEAN模式； - JobHandler：填写注解中的任务标识（orderTimeoutCloseHandler）； - 调度规则：cron表达式（如0 */1 * * * ? 表示每分钟执行一次）； 3. 启动任务，即可实现分布式环境下的定时执行。

四、定时任务避坑指南：10个常见问题及解决方案

定时任务看似简单，但在生产环境中容易出现各种问题，以下是10个高频坑点及规避方案：

1. 坑点1：单机多任务阻塞

现象：一个任务执行缓慢，导致其他任务排队等待，甚至错过执行时间。 规避：自定义定时任务线程池，设置合理的核心线程数（根据任务数量和执行耗时调整）；对耗时任务单独配置线程池。

2. 坑点2：分布式部署重复执行

现象：多实例部署时，同一个定时任务在多个实例上同时执行，导致数据重复（如重复发送通知）。 规避： - 简单场景：用分布式锁（如Redisson Lock），任务执行前先获取锁，获取失败则不执行； - 复杂场景：使用Quartz集群或XXL-Job，框架自带分布式协调机制。

3. 坑点3：任务执行时间过长，超过下次调度时间

现象：任务执行时间超过调度间隔（如每隔5秒执行一次，但任务需要6秒完成），导致任务叠加执行。 规避： - 用 fixedDelay 代替 fixedRate（fixedDelay以上次任务结束时间为基准）； - 优化任务逻辑，拆分耗时任务（如大数据量处理改为分片执行）； - 配置任务并发控制（如Quartz的 @DisallowConcurrentExecution 注解，禁止并发执行）。

4. 坑点4：任务失败无重试，导致业务中断

现象：任务因网络波动、第三方服务异常等临时问题失败，未触发重试，导致业务闭环中断（如订单未及时关闭）。 规避： - Spring Scheduler：结合 Spring Retry 框架，添加 @Retryable 注解； - Quartz/XXL-Job：配置任务重试策略（如失败后重试3次，每次间隔1分钟）。

5. 坑点5：日志无链路标识，排查困难

现象：定时任务日志混杂在业务日志中，无法快速定位某一次任务执行的完整日志。 规避：在任务执行前手动绑定MDC链路标识（如requestId），执行后清除，确保日志可追踪（参考之前MDC博客内容）。

6. 坑点6：任务参数硬编码，无法动态调整

现象：任务执行规则（如超时时间、执行间隔）硬编码在代码中，需要修改时必须重启服务。 规避： - Spring Scheduler：用 @Scheduled(cron = "${task.cron.clean-order}") 从配置文件读取参数； - XXL-Job：直接在调度中心界面修改调度规则，无需重启服务。

7. 坑点7：任务无监控，失败后无人知晓

现象：任务执行失败后，开发/运维人员无法及时获知，导致问题扩大（如报表未生成，影响经营决策）。 规避： - 简单场景：任务失败时发送告警邮件/钉钉消息； - 复杂场景：使用XXL-Job，配置任务失败告警（支持邮件、钉钉、企业微信）；结合Prometheus+Grafana监控任务执行状态。

8. 坑点8：大数据量任务执行超时

现象：处理大数据量时（如清理100万条过期数据），任务执行时间过长，被系统中断。 规避： - 分片执行：将任务拆分为多个子任务（如按用户ID分片），多个实例并行处理； - 分批处理：每次处理1000条数据，循环执行，避免单次处理数据量过大。

9. 坑点9：任务依赖导致执行顺序混乱

现象：任务A需要在任务B执行完成后执行（如先清理数据，再生成报表），但因调度机制导致顺序混乱。 规避： - 简单场景：用 fixedDelay 控制任务间隔，确保前一个任务完成； - 复杂场景：使用Quartz的任务依赖机制，或XXL-Job的任务编排功能。

10. 坑点10：服务重启时任务重复执行

现象：服务重启时，未执行完成的定时任务被重新触发，导致重复处理。 规避： - 任务幂等性设计：通过唯一标识（如订单号）确保重复执行不会产生副作用； - 持久化任务状态：将任务执行状态存入数据库，任务启动时先检查状态，避免重复执行。

五、高级用法：定时任务的进阶能力

对于复杂业务场景，还需要掌握定时任务的进阶能力，满足更高的业务需求：

1. 动态调整任务执行规则

需求：根据业务流量动态调整任务执行间隔（如高峰期每5分钟执行一次，低峰期每30分钟执行一次）。 实现方案： - Spring Scheduler：通过 ScheduledFuture 动态取消和重新创建任务； - XXL-Job：直接调用调度中心API修改任务的cron表达式，无需重启服务。

2. 任务分片执行（大数据量处理）

需求：处理1000万条用户数据，单实例执行耗时过长，需要多实例并行处理。 实现方案： - XXL-Job：支持分片任务，调度中心将任务拆分为多个分片，分配给不同执行器实例并行执行； - 自定义分片：基于Redis或数据库实现分片规则（如按用户ID取模分片），每个实例处理指定分片的数据。

3. 任务执行状态监控与可视化

需求：实时查看任务执行状态、历史执行记录、失败原因，支持可视化统计。 实现方案： - 自建监控：将任务执行状态存入数据库，开发监控界面； - 开源工具：使用XXL-Job的内置监控功能，或集成Prometheus+Grafana实现自定义监控面板。

4. 任务灰度发布与回滚

需求：新任务上线时先在部分实例执行（灰度），验证无问题后全量上线；出现问题时支持快速回滚。 实现方案： - XXL-Job：支持任务执行范围控制（指定执行器实例），实现灰度发布； - 自定义开关：通过配置中心（如Nacos）设置任务开关，支持快速启停和回滚。

六、总结：定时任务的选型与落地建议

定时任务的核心是"稳定、可靠、可监控"，选型和落地时需遵循以下原则：

  • 选型原则：简单场景用Spring Scheduler，复杂调度用Quartz，分布式场景用XXL-Job；避免过度设计，小项目无需引入重量级框架；
  • 落地核心：必须保证任务幂等性（避免重复执行问题）；必须配置监控告警（及时发现失败任务）；必须优化任务性能（避免阻塞和超时）；
  • 进阶方向：从"单机定时"向"分布式调度"演进，从"静态配置"向"动态调整"演进，从"被动排查"向"主动监控"演进。

最后，定时任务是业务闭环的重要保障，开发时不仅要关注"按时执行"，更要考虑异常处理、高可用和可运维性。希望本文的实战指南能帮助你避开坑点，实现高效、稳定的定时任务落地。

相关推荐
神奇小汤圆1 天前
MySQL索引明明建了，查询还是慢，排查发现踩了这些坑
后端
帅气的你1 天前
高并发下的防并发实战：C端/B端项目并发控制完全指南
后端
Ahtacca1 天前
解决服务间通信难题：Spring Boot 中 HttpClient 的标准使用姿势
java·spring boot·后端
嘻哈baby1 天前
局域网服务发现技术：mDNS与DNS-SD实战
后端
初次攀爬者1 天前
RAG知识库核心优化｜基于语义的智能文本切片方案（对比字符串长度分割）
人工智能·后端
JOEH601 天前
🔥 Redis 缓存穿透、击穿、雪崩：别再只背八股文了，实战代码教你彻底解决！
后端·架构
掘金一周1 天前
高德地图与Three.js结合实现3D大屏可视化 | 掘金一周 1.8
前端·人工智能·后端
ServBay1 天前
8 个 Python 自动化脚本让你告别重复劳动
后端·python
热门推荐
01GitHub 镜像站点02安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）03Labelme从安装到标注：零基础完整指南04Linux下V2Ray安装配置指南05【踩坑笔记】50系显卡适配的 PyTorch 安装06手把手教你通过Gemini3 pro 学生认证，白用一年，手慢无！07jdk21下载、安装（Windows、Linux、macOS）08GitLab 零基础入门指南：从安装到项目管理全流程09Opencode CLI 安装成功,但是启动失败10UV安装并设置国内源