springboot使用线程池的实际应用（一）

ゝ一纸荒年。 2024-03-17 11:01 29阅读 0赞

在实际Spring Boot项目中，我们可以使用Java的原生多线程或者使用Spring自带的线程池进行多线程编程。多线程的好处在于能够提高应用程序的运行效率，特别是在某些计算密集型场景下。以下是一些使用多线程的典型场景：

*  并发处理请求：例如Web应用程序有大量请求需要处理，将请求分配到多个工作线程中可以提高响应时间和系统吞吐量。
 *  数据库操作：在大型数据库操作时，将多个操作在不同的线程里处理。这样可以减少数据库操作的时间，从而提高数据库的并发处理能力。
 *  定时任务：使用多线程来执行定时任务，将耗时的操作在单独的线程中处理，避免定时任务占用系统资源，从而提高系统的稳定性和可靠性。

如果你要使用原生的Java多线程，一般可以使用Java多线程提供的Thread类或Runnable接口，实现多线程编程。如果要使用Spring多线程支持，可以使用Spring Boot的注解@Async来实现异步处理任务，或使用Spring Boot自带的线程池ThreadPoolTaskExecutor实现多线程编程。

\# 程序员

\#\# 来自你的消息:  
在实际springboot项目中，如何使用多线程，一般用在什么场景下

\#\# 来自 ChatGPT 的消息:  
在实际Spring Boot项目中，我们可以使用Java的原生多线程或者使用Spring自带的线程池进行多线程编程。多线程的好处在于能够提高应用程序的运行效率，特别是在某些计算密集型场景下。以下是一些使用多线程的典型场景：

\- 并发处理请求：例如Web应用程序有大量请求需要处理，将请求分配到多个工作线程中可以提高响应时间和系统吞吐量。  
\- 数据库操作：在大型数据库操作时，将多个操作在不同的线程里处理。这样可以减少数据库操作的时间，从而提高数据库的并发处理能力。  
\- 定时任务：使用多线程来执行定时任务，将耗时的操作在单独的线程中处理，避免定时任务占用系统资源，从而提高系统的稳定性和可靠性。

\#\# 来自你的消息:  
就拿数据库操作举例吧

\#\# 来自 ChatGPT 的消息:  
好的，举个例子，比如我们在数据库中需要进行并行的查询操作，或者进行批量的更新操作，这些操作都是非常耗时的。为了减少这些操作对系统资源的占用，我们可以使用多线程来并行处理这些操作。

在Java中，我们可以使用多线程池来实现多线程，Spring Boot中提供了一种方便的方式来管理线程池，那就是使用ThreadPoolTaskExecutor。我们可以在配置类中自定义线程池，并注入到需要执行的方法中，例如：

\`\`\`

@Configuration
    @EnableAsync
    public class AppConfig implements AsyncConfigurer {
     
        @Bean(name = "taskExecutor")
        public Executor taskExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(10);
            executor.setMaxPoolSize(20);
            executor.setQueueCapacity(30);
            return executor;
        }
     
        @Override
        public Executor getAsyncExecutor() {
            return taskExecutor();
        }
     
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
            return new SimpleAsyncUncaughtExceptionHandler();
        }
    }

\`\`\`

在上述代码中，我们通过自定义线程池的方式来实现数据库操作的异步执行，其中setCorePoolSize、setMaxPoolSize、setQueueCapacity分别表示线程池的最小线程数量、最大线程数量以及工作队列的容量大小。

接下来，我们只需要在需要异步执行的方法上面添加@Async注解即可，例如：

\`\`\`

public class UserRepositoryImpl implements UserRepositoryCustom {
     
        @Autowired
        private UserRepository userRepository;
     
        @Autowired
        private ThreadPoolTaskExecutor taskExecutor;
     
        @Async("taskExecutor")
        @Override
        public CompletableFuture<List<User>> findByAgeGreaterThan(int age) {
            return CompletableFuture.completedFuture(userRepository.findByAgeGreaterThan(age));
        }
    }

\`\`\`

在上述代码中，我们使用了findByAgeGreaterThan方法进行查询操作，并将该方法标记为异步执行，Spring Boot会自动使用我们自定义的线程池进行异步执行。

当然，具体实现还需要根据具体情况进行调整，这里只是一个简单的示例。

\#\# 来自你的消息:  
那么你调用下这个findByAgeGreaterThan的话，会启动几个线程处理？

\#\# 来自 ChatGPT 的消息:  
答案依据我不同的设置而异，但是我可以讲解一下可能的情况。在上述的配置中，我们使用了线程池的方式来实现异步操作，我们设置了线程池的核心线程数是10，最大线程数为20，工作队列的容量为30。

假设我们调用findByAgeGreaterThan方法时，有30个用户年龄大于某个值，这个时候每个查询操作会被放入工作队列中。在这个过程中，如果线程池中的线程数量还没有达到10个，那么这个30个查询操作中的前10个会被分配到10个线程中执行，剩下的20个查询操作会被存储在工作队列中。

当有新的查询操作进入工作队列时，如果线程池中的线程数量仍然没有达到最大值20，那么会有新的线程被创建，并执行这些查询操作。

如果线程池中的线程数量已经达到了最大值20，那么新的查询操作会被放入工作队列中，等待线程池中的线程空闲出来之后再执行。

综上所述，具体线程数量取决于线程池中的策略设置、当前线程池中的线程数、工作队列中待执行任务数量等因素。

\#\# 来自你的消息:  
这些线程会自动分片数据？

\#\# 来自 ChatGPT 的消息:  
不会，线程池只是用来管理线程的，它并不会自动分片数据。在上面的示例中，如果查询结果中有30个用户年龄大于某个值，30个查询操作会被放在工作队列中等待执行。线程池中创建的线程会依次取出工作队列中的任务执行。每个线程只会处理一个查询操作，也就是说，一个线程处理一个查询操作，这个查询操作的结果仍然是原来的全部数据。

如果要对数据进行分片处理，可以在查询时手动将数据切分成多个片段，将每个片段作为一个任务，由线程池中的线程分配执行，这样每个线程就只需要处理片段中的一部分数据。可以使用像MyBatis Plus这样的框架，在写SQL时使用分页查询对数据进行分片处理，或者使用像Elasticsearch这样的搜索引擎，使用分片和副本来处理数据。

\#\# 来自你的消息:  
有30个用户年龄大于某个值，这个时候每个查询操作会被放入工作队列中 。 这句话我不懂

\#\# 来自 ChatGPT 的消息:  
抱歉，可能我表述不够清晰导致你的理解有误。我再解释一下：

假设我们有一个User表，其中有age字段代表用户年龄。我们打算执行一个查询操作来查找所有年龄大于某个值的用户。比如我们要找到所有年龄大于30岁的用户。

那么我们可以写出这样的SQL语句：

SELECT \* FROM User WHERE age > 30

当我们执行这个SQL语句时，数据库会返回所有满足条件的用户数据，也就是年龄大于30岁的所有用户。假设这个查询结果中共有30个用户数据，这个时候我们的查询操作就结束了。

上面提到的“每个查询操作会被放入工作队列中”这句话，实际上是一个语言错误，抱歉让您产生困惑。其实正确的表述应该是“查询结果中的30个用户数据会被放入工作队列中等待处理”，也就是说，我们将查询操作获取到的结果数据放入一个队列中，然后使用线程池来处理这些数据。

在这个示例中，我们并没有将每个查询操作都放入工作队列中，而是将查询操作获取到的结果数据放入工作队列中等待处理。希望我的解释能够更加清晰明了。

假如一个用户调用这个方法：  
@Async("taskExecutor")  
@Override  
public CompletableFuture<List<User>> findByAgeGreaterThan(int age) \{  
return CompletableFuture.completedFuture(userRepository.findByAgeGreaterThan(age));  
\} 它会执行几次？

\#\# 来自 ChatGPT 的消息:  
如果一个用户调用了findByAgeGreaterThan方法，那么这个方法会在当前线程中立即执行。当进入到方法体中的 @Async("taskExecutor") 注解时，这个方法会以异步非阻塞的方式执行，并在另一个线程中执行查询操作。

因为我们在方法体中使用了CompletableFuture.completedFuture()方法，所以我们会立即获得一个已经完成的CompletableFuture对象，这个对象包含了查询操作得到的结果集（是一个User对象列表），并且这个结果集的获取也是非阻塞的。

具体来说，假设我们有10个用户同时调用了这个方法，那么这个方法会被执行10次，但是这10个用户会共用一个线程池中的线程去执行查询操作，而且查询操作是异步执行的，所以并不会阻塞当前线程。因此，这个方法执行的次数和查询操作执行的次数是不一样的，每个用户只会调用这个方法一次，并获得一个CompletableFuture对象，这个对象可以用于获取查询结果。

\#\# 来自你的消息:  
那么你写一个controller去调用这个方法，并且告诉我它到底有什么用，写一个业务逻辑，要不然这和直接查询有什么区别，为什么要异步操作？

\#\# 来自你的消息:  
@Async("taskExecutor")  
@Override  
public CompletableFuture<List<User>> findByAgeGreaterThan(int age) \{  
return CompletableFuture.completedFuture(userRepository.findByAgeGreaterThan(age));  
\}写一个方法去调用它，充分的实现它异步的好处

\#\# 来自 ChatGPT 的消息:  
假设我们现在有一个业务需求是查询年龄大于等于30岁的用户，并将所有这些用户的名字以及年龄均大于35岁的用户的职业信息保存到一个文件中。如果我们使用同步的方式来实现这个需求，那么可能需要的时间会比较长，因为查询和计算操作都需要执行完毕后才能继续进行。现在我们可以借助Spring中提供的异步调用机制来提高效率。

首先，我们先定义一个Controller类，并提供一个RESTful风格的接口，用于查询并计算这些数据：\`\`\`java

@RestController
    @RequestMapping("/users")
    public class UserController {
    
        private final UserService userService;
    
        public UserController(UserService userService) {
            this.userService = userService;
        }
    
        @GetMapping("/")
        public CompletableFuture<String> getUsers() {
            return userService.findUsersByAgeGreaterThan(30)
                    .thenApply(users -> users.stream()
                            .filter(user -> user.getAge() > 35)
                            .map(user -> user.getName() + ":" + user.getAge())
                            .collect(Collectors.toList()))
                    .thenApply(userNames -> {
                        String fileName = "users-info.txt";
                        try {
                            // 将符合条件的用户信息写入到文件中
                            Files.write(Paths.get(fileName), userNames);
                            return "Saved users info to " + fileName;
                        } catch (IOException e) {
                            e.printStackTrace();
                            return "Failed to write users info to file";
                        }
                    });
        }
    }

\`\`\`

上面的代码中，我们先注入UserService，并在getUsers()方法中调用它提供的异步查询方法findUsersByAgeGreaterThan()，它会返回一个CompletableFuture<List<User>>对象。这个对象会异步地执行查询操作，查询出年龄大于30岁的所有User对象列表，并在获取到查询结果后，将这个结果传给下一个阶段。

下一个阶段中，我们使用filter()方法过滤出年龄大于35岁的用户，然后使用map()方法将这些用户的名字和年龄拼接成一个字符串，最后使用collect()方法将所有这样的结果收集为一个字符串列表。

在最后一个阶段中，我们将符合条件的用户信息写入一个文本文件中，并将结果作为字符串返回给调用方。

需要注意的是，这个接口方法返回的是一个CompletableFuture<String>对象，这个对象会异步地执行告诉调用方查询、计算以及写文件操作的结果。因此，调用这个接口的用户无需等待查询和计算操作的完成，可以在后台继续执行其他任务，提高了效率。

我们可以使用Postman或浏览器直接访问http://localhost/users/路径，执行这个接口方法。接口返回的是一个CompletableFuture对象，最终结果会以同步的方式呈现给调用方。对于异步的操作，我们并不知道它何时会结束，因此如果我们想要知道它何时结束以及获取它的结果，可以通过回调函数的方式来实现：\`\`\`java

CompletableFuture<String> future = userService.findUsersByAgeGreaterThan(30)
                    .thenApply(users -> users.stream()
                            .filter(user -> user.getAge() > 35)
                            .map(user -> user.getName() + ":" + user.getAge())
                            .collect(Collectors.toList()))
                    .thenApply(userNames -> {
                        String fileName = "users-info.txt";
                        try {
                            Files.write(Paths.get(fileName), userNames);
                            return "Saved users info to " + fileName;
                        } catch (IOException e) {
                            e.printStackTrace();
                            return "Failed to write users info to file";
                        }
                    });
    
            // 添加回调函数处理结果
            future.whenComplete((result, throwable) -> {
                if (throwable != null) {
                    System.out.println("error: " + throwable.getMessage());
                } else {
                    System.out.println("result: " + result);
                }
            });

\`\`\`

在上面的代码中，我们首先获得一个CompletableFuture对象，然后使用whenComplete()方法添加回调函数。这个回调函数用于处理异步操作的结果，如果异步操作抛出了异常，那么回调函数会接收到异常信息；如果异步操作成功完成，那么回调函数会接收到操作结果。

这段代码的作用是定义了一个异步任务，在异步任务执行完成后，打印执行结果。具体解释如下：

首先，我们创建了一个名为future的CompletableFuture对象，它会异步地执行查询列表并将符合条件的用户信息写入到文件中的操作。

接着，我们调用了CompletableFuture对象的whenComplete()方法，并定义了回调函数，用于处理异步操作的执行结果。当异步操作执行完毕时，回调函数会被执行。

在回调函数中，我们判断了是否存在异常。如果存在异常，则输出错误信息；如果执行成功，则输出结果信息。这样的方式非常方便，让我们可以在异步操作执行完毕后及时地获取执行结果，而无需在等待过程中阻塞线程。

要返回异步任务的结果，我们可以在Controller中直接返回CompletableFuture对象。在异步任务完成之前，客户端仍然会保持连接状态，因此需要根据具体情况而定，决定客户端如何处理这种异步响应。

假设我们在Web应用程序中使用这段代码，在客户端使用Web浏览器或类似工具时，异步任务执行完成后会显示在控制台中。如果客户端使用Ajax方式向服务器发送请求，它可以使用JavaScript从前端获取到异步结果并及时处理。最后，需要注意的是，当使用异步任务时，由于线程切换和上下文切换等操作的开销较小，因此可以提高应用程序的性能和并发能力。