Spring Boot 多线程例子

在Spring Boot中，多线程可以通过Java的并发工具来实现。以下是一些常见的多线程实现方法：

 

1. 使用`@Async`注解和`CompletableFuture`：

 

首先，需要在Spring Boot应用的主类上添加`@EnableAsync`注解，以启用异步支持。

 

```java

@SpringBootApplication

@EnableAsync

public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);

    }

}

```

 

接下来，创建一个服务类，并在需要异步执行的方法上添加`@Async`注解。同时，返回`CompletableFuture`以便于处理异步结果。

 

```java

@Service

public class AsyncService {

    @Async

    public CompletableFuture<String> asyncMethod() {

        // 模拟耗时操作

        try {

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        return CompletableFuture.completedFuture("异步任务完成");

    }

}

```

 

在控制器或其他服务类中，注入`AsyncService`并调用异步方法。

 

```java

@RestController

public class MyController {

    @Autowired

    private AsyncService asyncService;

 

    @GetMapping("/async")

    public ResponseEntity<String> asyncEndpoint() throws InterruptedException, ExecutionException {

        CompletableFuture<String> result = asyncService.asyncMethod();

        return ResponseEntity.ok("异步请求已发送，结果：" + result.get());

    }

}

```

 

2. 使用`ExecutorService`：

 

在Spring Boot应用中，可以通过`@Bean`注解创建一个`ExecutorService`实例。

 

```java

@Configuration

public class ExecutorConfig {

    @Bean

    public ExecutorService executorService() {

        return Executors.newFixedThreadPool(5);

    }

}

```

 

然后，在服务类中使用`ExecutorService`来执行多线程任务。

 

```java

@Service

public class ThreadPoolService {

    @Autowired

    private ExecutorService executorService;

 

    public void executeTask(Runnable task) {

        executorService.execute(task);

    }

}

```

 

在控制器或其他服务类中，注入`ThreadPoolService`并提交任务。

 

```java

@RestController

public class MyController {

    @Autowired

    private ThreadPoolService threadPoolService;

 

    @GetMapping("/thread-pool")

    public ResponseEntity<String> threadPoolEndpoint() {

        threadPoolService.execute(() -> {

            // 模拟耗时操作

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println("任务完成");

        });

        return ResponseEntity.ok("任务已提交到线程池");

    }

}

```

 

在Spring Boot中，通过`@Async`注解和`CompletableFuture`或者使用`ExecutorService`时，可以通过以下方式传递参数给异步任务：

 

1. 使用`@Async`注解和`CompletableFuture`传递参数：

 

在服务类中，修改`asyncMethod`方法，使其接受参数。然后在方法内部，将这些参数传递给实际的异步任务。

 

```java

@Service

public class AsyncService {

    @Async

    public CompletableFuture<String> asyncMethod(String param1, int param2) {

        // 传递参数给异步任务

        return CompletableFuture.supplyAsync(() -> {

            // 使用参数执行异步任务

            System.out.println("异步任务参数：param1=" + param1 + ", param2=" + param2);

            return "异步任务完成";

        });

    }

}

```

 

在控制器或其他服务类中，注入`AsyncService`并调用异步方法，同时传递参数。

 

```java

@RestController

public class MyController {

    @Autowired

    private AsyncService asyncService;

 

    @GetMapping("/async")

    public ResponseEntity<String> asyncEndpoint() throws InterruptedException, ExecutionException {

        String param1 = "Hello";

        int param2 = 42;

        CompletableFuture<String> result = asyncService.asyncMethod(param1, param2);

        return ResponseEntity.ok("异步请求已发送，结果：" + result.get());

    }

}

```

 

2. 使用`ExecutorService`传递参数：

 

在服务类中，创建一个新的方法（例如`executeTaskWithParams`），该方法接受`Runnable`和一个`Object[]`参数数组。在方法内部，将参数数组传递给`Runnable`的实现。

 

```java

@Service

public class ThreadPoolService {

    @Autowired

    private ExecutorService executorService;

 

    public <T> void executeTaskWithParams(Runnable task, T... params) {

        executorService.execute(() -> {

            // 使用传递的参数执行任务

            System.out.println("任务参数：" + Arrays.toString(params));

            task.run();

        });

    }

}

```

 

创建一个实现`Runnable`接口的类，并在其`run`方法中使用传递的参数。

 

```java

public class MyTask implements Runnable {

    private String param1;

    private int param2;

 

    public MyTask(String param1, int param2) {

        this.param1 = param1;

        this.param2 = param2;

    }

 

    @Override

    public void run() {

        System.out.println("异步任务参数：param1=" + param1 + ", param2=" + param2);

    }

}

```

 

在控制器或其他服务类中，注入`ThreadPoolService`并提交带参数的任务。

 

```java

@RestController

public class MyController {

    @Autowired

    private ThreadPoolService threadPoolService;

 

    @GetMapping("/thread-pool")

    public ResponseEntity<String> threadPoolEndpoint() {

        String param1 = "Hello";

        int param2 = 42;

        threadPoolService.executeTaskWithParams(new MyTask(param1, param2));

        return ResponseEntity.ok("带参数的任务已提交到线程池");

    }

}

```