网站空间密码网站如何赚钱

使用ExecutorService和@Async来使用多线程

采用ExecutorService来使用多线程

我们直接来通过一段代码来看一下多线程的过程，大致就是通过多线程来生成图片

@Service
public class NameService {private final ExecutorService executorService = Executors.newFixedThreadPool(10); // 创建一个固定大小的线程池public void createImg(String fileNamePrefix) {// 假设我们有一组需要生成的图片List<String> imagePrefixes = getImagePrefixes(fileNamePrefix);try {for (String prefix : imagePrefixes) {// 提交任务executorService.submit(() -> {generateImage(prefix); // 生成图片的方法});}} catch(Exception e) {e.printStackTrace();} finally {// 关闭线程池，但允许已提交的任务继续执行executorService.shutdown();// 下面是为了确保线程池关闭，手动设置一个时间，如果线程60秒没有执行完，则强制关闭该线程，我这里不需要// try {// if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {// 	executorService.shutdownNow();// }// } catch (InterruptedException e) {// 	executorService.shutdownNow();// 	Thread.currentThread().interrupt();// }}}// 模拟要生成的图片名列表private List<String> getImagePrefixes(String fileNamePrefix) {// 获取需要生成的图片前缀列表，示例代码return Arrays.asList(fileNamePrefix + "_1", fileNamePrefix + "_2", fileNamePrefix + "_3");}// 生成图片的方法private void generateImage(String prefix) {// 生成图片并保存到本地的方法，示例代码System.out.println("Generating image for prefix: " + prefix);// 实际的图片生成逻辑,这里简单用一个延时函数代替try { Thread.sleep(1000); // 模拟生成图片的时间 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("Generating image for prefix: " +}
}// 注释相关解释：
//awaitTermination：等待所有任务在指定时间内完成。如果在指定时间（60 秒）内所有任务没有完成，则调用 executorService.shutdownNow() 强制关闭线程池，并中断所有正在执行的任务。
//异常处理：处理可能的 InterruptedException，确保线程池能够被正确关闭。

多线程过程的详细解释

1. 创建线程池： 使用 Executors.newFixedThreadPool(10) 创建一个固定大小为 10 的线程池。你可以根据需要调整线程池的大小。
2. 提交任务： 使用 executorService.submit() 方法将图片生成任务提交给线程池，这些任务会被放入线程池的任务队列中，等待线程池中的线程来执行。
3. 执行任务： 线程池中的线程会从任务队列中取出任务并执行。使用的是 ExecutorService 和多线程，即使 for 循环结束，提交的任务仍会在后台继续运行，直到所有任务完成。
4. 关闭线程池： 调用 executorService.shutdown() 方法后，线程池不再接受新任务，但会继续执行已经提交的任务，直到所有任务执行完毕。如果 generateImage 方法耗时较长，那么这些任务会在后台继续运行，直到所有任务完成。

多线程使得任务的提交与执行分离。for 循环快速提交任务，而线程池在后台并发地执行这些任务。这种异步执行的机制允许你同时处理多个任务，而不需要等待每个任务的完成。

注意事项

• 任务数量：确保线程池大小与任务数量合理匹配，以免线程过多或过少影响性能。
• 异常处理：可以在任务中添加异常处理逻辑，确保不会因为某个任务失败而影响其他任务的执行。

优点

• 提高并发性：多个任务可以同时进行，提高效率。
• 主线程不中断：主线程可以继续执行其他操作，而不需要等待每个任务的完成。

使用@Async来使用多线程

Spring 提供了 @Async 注解，用于简化多线程编程。通过这个注解让 Spring 自动管理线程池。

启用异步支持： 首先，在 Spring Boot 应用中启用异步支持。可以在主应用类或配置类上添加 @EnableAsync 注解。

标记异步方法： 在需要异步执行的方法上添加 @Async 注解。Spring 会在后台线程池中执行这些方法，不会阻塞主线程。

具体例子咱们可以通过下面的对比来看。

对比@Async和ExecutorService的多线程使用方式

使用 ExecutorService 的服务类

package caj.springboot.service;import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.List;
import java.util.Arrays;/*** @description: 使用 `ExecutorService` 的服务类* @author: CAJ* @time: 2025/1/2 20:13*/
@Service
public class ExecutorServiceNameService {private final ExecutorService executorService = Executors.newFixedThreadPool(10); // 创建一个固定大小的线程池public void createImg(String fileNamePrefix) {List<String> imagePrefixes = getImagePrefixes(fileNamePrefix);long startTime = System.currentTimeMillis();for (String prefix : imagePrefixes) {executorService.submit(() -> {generateImage(prefix); // 生成图片的方法});}executorService.shutdown();// 用来判断线程池中的所有任务是否都已经完成。while (!executorService.isTerminated()) {// 等待所有任务完成}long endTime = System.currentTimeMillis();System.out.println("ExecutorService 总耗时: " + (endTime - startTime) + " 毫秒");}private List<String> getImagePrefixes(String fileNamePrefix) {return Arrays.asList(fileNamePrefix + "_1", fileNamePrefix + "_2", fileNamePrefix + "_3");}private void generateImage(String prefix) {try {Thread.sleep(1000); // 模拟生成图片的时间} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("Generating image for prefix: " + prefix);}
}

使用 @Async 的服务类

（之后将这个异步方法抽出来了，这里面只是调用，否则无法异步执行）

package caj.springboot.service;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;/*** @description:* @author: CAJ* @time: 2025/1/2 20:13*/
@Service
public class AsyncNameService {@Autowiredprivate AsyncTask asyncTask;public void createImg(String fileNamePrefix) {List<String> imagePrefixes = getImagePrefixes(fileNamePrefix);long startTime = System.currentTimeMillis();// 下面这样写只是为了确保整个异步过程结束才会记录endTime，正常使用就for循环然后调用方法即可List<CompletableFuture<Void>> futures = imagePrefixes.stream().map(prefix -> asyncTask.generateImageAsync(prefix)).collect(Collectors.toList());// 等待所有异步任务完成CompletableFuture<Void> allOf = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));try {allOf.get(); // 阻塞等待所有任务完成} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}long endTime = System.currentTimeMillis();System.out.println("Async 总耗时: " + (endTime - startTime) + " 毫秒");}private List<String> getImagePrefixes(String fileNamePrefix) {return Arrays.asList(fileNamePrefix + "_1", fileNamePrefix + "_2", fileNamePrefix + "_3");}//    本来将异步方法直接在这个类中写，但是发现无论如何都无法异步执行，顾后面将异步方法抽出来
//    /**
//     * 在异步方法 generateImageAsync 中返回一个 CompletableFuture，表示异步任务的完成。
//     * @param prefix
//     * @return
//     */
//    @Async("taskExecutor")
//    public CompletableFuture<Void> generateImageAsync(String prefix) {
//        System.out.println(Thread.currentThread().getName() + " is processing " + prefix);
//        generateImage(prefix);
//        return CompletableFuture.completedFuture(null);
//    }
//
//
//    private void generateImage(String prefix) {
//        try {
//            Thread.sleep(1000); // 模拟生成图片的时间
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }
//        System.out.println("Generating image for prefix: " + prefix);
//    }
}

异步任务类

package caj.springboot.service;import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.concurrent.CompletableFuture;/*** @description: 异步任务类* @author: CAJ* @time: 2025/1/2 20:52*/
@Component
public class AsyncTask {@Async("taskExecutor")public CompletableFuture<Void> generateImageAsync(String prefix) {generateImage(prefix);return CompletableFuture.completedFuture(null);}private void generateImage(String prefix) {try {Thread.sleep(1000); // 模拟生成图片的时间} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("Generating image for prefix: " + prefix);}
}

自定义线程池

@Configuration
@EnableAsync
public class AsyncConfig {@Bean(name = "taskExecutor")public Executor taskExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(10);executor.setMaxPoolSize(20);executor.setQueueCapacity(500);executor.setThreadNamePrefix("Async-");executor.initialize();return executor;}
}

1. 自定义线程池配置类：通过实现 AsyncConfigurer 接口和定义 getAsyncExecutor 方法，配置自定义的线程池。
2. 自定义线程池参数：设置核心线程数、最大线程数、队列容量和线程名前缀。

使用 @Async 注解和自定义线程池，你可以轻松地将方法异步执行，从而提高并发处理能力并优化应用程序性能。

主应用类

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;@SpringBootApplication
public class AsyncDemoApplication {public static void main(String[] args) {SpringApplication.run(AsyncDemoApplication.class, args);}@BeanCommandLineRunner run(ExecutorServiceNameService executorServiceNameService, AsyncNameService asyncNameService) {return args -> {System.out.println("使用 ExecutorService：");executorServiceNameService.createImg("test");System.out.println("使用 @Async：");asyncNameService.createImg("test");};}
}

运行结果：
使用 ExecutorService：
Generating image for prefix: test_2
Generating image for prefix: test_1
Generating image for prefix: test_3
ExecutorService 总耗时: 1003 毫秒
使用 @Async：
Generating image for prefix: test_2
Generating image for prefix: test_1
Generating image for prefix: test_3
Async 总耗时: 1009 毫秒
由于这里的例子设置时间比较短，所以最终时间差不多

解释

1. ExecutorServiceNameService：使用 ExecutorService 处理图片生成任务，创建一个固定大小为 10 的线程池。
2. AsyncNameService：使用 @Async 注解让方法异步执行，依赖 Spring 管理的线程池。
3. 主应用类：在应用启动时，运行两个服务并输出各自的总耗时，以便对比。

运行这个示例

• 将这两个服务类和主应用类放入项目中，运行主应用程序。
• 程序会分别调用 ExecutorServiceNameService 和 AsyncNameService 的 createImg 方法，并输出各自的总耗时。

通过这个对比，你可以清楚地看到使用 ExecutorService 和 @Async 的不同之处以及它们的性能表现。

注意点：

1. 为了确保 @Async 注解生效，可以将异步方法放在一个独立的类中，并从主服务类调用这个异步方法。这样，Spring AOP 代理能够正确拦截方法调用并应用异步特性，因为Spring 使用 AOP 代理来拦截方法调用并提供额外的功能，比如事务管理、异步执行等，
2. 同一个类内部自调用：当你在同一个类内部调用带有 @Async 注解的方法时，Spring AOP 代理无法拦截这个调用，从而无法应用异步特性。这是因为代理对象拦截方法调用的前提是调用发生在代理对象本身上，而不是在同一个类内部。