第27章_Java分布式基础

授课语音

学习Spring Boot中的多线程技术及其应用

多线程技术是提升应用性能和响应能力的关键手段，尤其在高并发的场景中，能够显著提升系统吞吐量和资源利用率。在Spring Boot中，通过合理的多线程技术实现异步任务、并发处理等，可以提高应用的执行效率。本课件将详细介绍Spring Boot中的多线程技术以及如何在实际项目中进行应用。

1. 多线程概述与Spring Boot中的应用场景

1.1 多线程技术概述

多线程技术可以让一个程序同时处理多个任务，通常应用于以下场景：

I/O 密集型操作：如文件操作、数据库查询等。
CPU 密集型操作：如复杂计算、数据分析等。
并发处理：多个任务可以并行执行，提高整体性能。

1.2 Spring Boot中的多线程应用场景

异步任务处理：如异步调用外部API、异步处理消息队列等。
并发数据处理：在高并发场景中处理大量数据。
后台定时任务：如定时清理任务、定时同步任务等。

2. Spring Boot中的多线程实现方式

2.1 使用`@Async`注解实现异步执行

Spring Boot 提供了 @Async 注解来实现异步任务，使得方法可以异步执行而不阻塞调用线程。通过开启异步支持，可以在后台执行任务。

2.1.1 启用异步支持

首先需要在 Spring Boot 中启用异步支持，可以通过 @EnableAsync 注解来启用。

@Configuration
@EnableAsync  // 启用异步支持
public class AsyncConfig {
}

2.1.2 异步方法的使用

使用 @Async 注解标记需要异步执行的方法。Spring 会自动将这些方法放入异步线程池中执行。

@Service
public class AsyncService {

    @Async
    public void executeAsyncTask() {
        try {
            // 模拟长时间任务
            Thread.sleep(5000);
            System.out.println("异步任务执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

中文注释：

@Async 注解标记的方法会在独立的线程中执行，主线程不阻塞，可以立即返回。
executeAsyncTask 方法模拟了一个耗时的任务，执行时不会阻塞主线程。

2.1.3 设置线程池

为了提高性能和避免创建过多的线程，Spring Boot 允许通过配置文件来设置线程池。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);  // 设置核心线程池大小
        executor.setMaxPoolSize(10);  // 设置最大线程池大小
        executor.setQueueCapacity(25);  // 设置队列容量
        executor.initialize();
        return executor;
    }
}

中文注释：

ThreadPoolTaskExecutor 用于创建和管理线程池，通过配置核心线程数、最大线程数和队列容量来调优性能。

3. 使用`@Scheduled`实现定时任务

Spring Boot 提供了 @Scheduled 注解来实现定时任务，可以在指定的时间间隔或特定的时间点执行任务。

3.1 启用定时任务

首先需要在配置类中启用定时任务支持。

@Configuration
@EnableScheduling  // 启用定时任务
public class ScheduledConfig {
}

3.2 编写定时任务

使用 @Scheduled 注解标记需要定时执行的方法。可以使用 fixedRate、fixedDelay 或 cron 表达式来控制任务执行的频率。

@Service
public class ScheduledService {

    @Scheduled(fixedRate = 5000)  // 每隔5秒执行一次
    public void executeScheduledTask() {
        System.out.println("定时任务执行中...");
    }
}

中文注释：

@Scheduled(fixedRate = 5000)：表示每隔 5 秒执行一次任务。
executeScheduledTask 方法将定期执行，打印日志以确认任务执行。

3.3 使用Cron表达式

@Scheduled 还支持使用 Cron 表达式来定义复杂的定时任务执行计划。

@Scheduled(cron = "0 0/1 * * * ?")  // 每分钟执行一次
public void executeCronTask() {
    System.out.println("每分钟执行一次的定时任务");
}

中文注释：

cron = "0 0/1 * * * ?"：Cron 表达式定义每分钟执行一次任务。

4. 多线程并发处理

Spring Boot 支持多线程并发处理任务，可以利用 Java 的 ExecutorService 来执行并发任务。通过合理配置线程池，可以有效地管理多线程任务。

4.1 使用`ExecutorService`

@Service
public class ConcurrentService {

    private ExecutorService executorService = Executors.newFixedThreadPool(10);  // 创建一个固定大小的线程池

    public void executeTasksConcurrently() {
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                System.out.println("并发任务执行中：" + Thread.currentThread().getName());
            });
        }
    }
}

中文注释：

创建了一个固定大小为 10 的线程池 ExecutorService，并发提交 10 个任务。
每个任务都会在不同的线程中执行，输出当前线程的名称。

4.2 使用`@Async`与`ExecutorService`结合

除了使用线程池，Spring Boot 还支持将 ExecutorService 与 @Async 注解结合使用。

@Service
public class CombinedAsyncService {

    @Async
    public void executeAsyncWithExecutor() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.submit(() -> {
            System.out.println("结合使用@Async与ExecutorService的任务：" + Thread.currentThread().getName());
        });
    }
}

中文注释：

通过 @Async 与 ExecutorService 结合，任务仍然可以在独立线程中执行，而 ExecutorService 则控制线程池。

5. 线程安全与并发控制

在并发编程中，线程安全是至关重要的，尤其在访问共享资源时。Spring Boot 提供了多种方式来保证线程安全。

5.1 使用 `synchronized` 关键字

synchronized 关键字可以确保方法或代码块在同一时间只能有一个线程访问。

@Service
public class SynchronizedService {

    private int counter = 0;

    @Synchronized
    public void incrementCounter() {
        counter++;
    }
}

中文注释：

incrementCounter 方法被 @Synchronized 注解标记，确保同一时刻只有一个线程可以执行该方法，防止并发问题。

5.2 使用 `ReentrantLock`

ReentrantLock 提供了更灵活的锁机制，可以用于精确控制线程的访问。

@Service
public class LockService {

    private final ReentrantLock lock = new ReentrantLock();

    public void performTaskWithLock() {
        lock.lock();
        try {
            System.out.println("执行有锁的任务");
        } finally {
            lock.unlock();
        }
    }
}

中文注释：