SpringBoot异步处理任务

╰半夏微凉° 2023-02-20 15:58 100阅读 0赞

## 名词解释 ##

1）同步：等用户所有操作结束后，才会返回程序的处理状态。

2）异步：直接返回给用户指定的状态，同时程序在后台继续运行，用户不用等待。

## 实现 ##

### 同步实现 ###

@Autowired
    	private TaskAsync taskAsync;
    
    	/**
    	 * 同步处理的方式
    	 */
    	@GetMapping("/test2")
    	public String test2() {
    		taskAsync.getTest2();
    		System.out.println(Thread.currentThread().getName() + "==========主线程名");
    		return "同步,正在解析......";
    	}

@Component
    public class TaskAsync {
    
    
    	public void getTest2() {
    		Building building = new Building();
    
    		synchronized (building) {
    			try {
    				for (int i = 0; i <= 100; i++) {
    					System.out.println(Thread.currentThread().getName() + "----------同步：>" + i);
    					building.wait(200);
    				}
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }

这种同步的方式处理，会发现，当这100此循环完成后，页面才会返回 ：同步,正在解析......。当后台在循环处理时，前台的页面始终处于等待状态。可以发现，使用都是一个线程在处理：

![SouthEast][]

### **异步实现方式一** ###

使用线程池，创建新的线程去处理，如下：

/**
         * 异步处理方式一：线程池，创建新线程处理
    	 */
    	@GetMapping("/test3")
    	public String test3() {
    		ExecutorService service = Executors.newFixedThreadPool(5);
    		RunnableTask1 task1 = new RunnableTask1();
    		service.execute(task1);
    		System.out.println("=========》当前线程名：" + Thread.currentThread().getName());
    
    		return "异步,正在解析......";
    	}」

public class RunnableTask1 implements Runnable {
    	@Override
    	public void run() {
    		Building building = new Building();
    
    		synchronized (building) {
    			try {
    				for (int i = 0; i <= 100; i++) {
    					System.out.println(Thread.currentThread().getName() + "----------异步：>" + i);
    					building.wait(200);
    				}
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }

我们看控制台，会发现，主线程和处理任务的线程，不是一个线程，也就是，当页面请求后，主线程会返回我们想要返回的标识，这里返回的是一个字符串：异步，正在解析......，而线程池新开了一个线程，在后台处理业务逻辑。所以，此时访问接口后，会立马返回，页面不用等待，处理逻辑在后台默默进行。控制台如下：  
![SouthEast 1][]

### **异步实现方式二** ###

这种方式，是SpringBoot自身的一种异步方式，使用注解实现，非常方便。

SpringBoot要使用@Async需要以下两个步骤：

**1.使用@EnableAsync开启异步；（在项目的启动类上）**

**2.定义Spring组件，使用@Component和@Async；**

注意，这里的异步方法，只能在自身之外调用，在本类调用是无效的。

/**
    	 * 异步方法
    	 * 有@Async注解的方法，默认就是异步执行的，会在默认的线程池中执行，但是此方法不能在本类调用；启动类需添加直接开启异步执行@EnableAsync。
    	 */
    	@GetMapping("/test1")
    	public String test1() {
    		taskAsync.getTest1();
    		System.out.println(Thread.currentThread().getName() + "=========================");
    		return "异步,正在解析......";
    	}

import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Component;
    
    @Component
    public class TaskAsync {
    
    	@Async
    	public String getTest1() {
    		Building building = new Building();
    		synchronized (building) {
    			try {
    				for (int i = 1; i <= 100; i++) {
    					System.out.println(Thread.currentThread().getName() + "----------异步：>" + i);
    					building.wait(200);
    				}
    				return "执行异步任务完毕";
    			} catch (Exception ex) {
    				ex.printStackTrace();
    			}
    		}
    		return Thread.currentThread().getName() + "执行完毕";
    	}
    
    }

看控制台，会发现，页面发出请求后，主线程会返回，而内置的线程池会新开线程，在后台执行任务。此时页面不用等待，可以继续其他操作。

![SouthEast 2][]

可以看到，很多情况下，异步处理，是一种很常见，而且很高效的方式，个人比较喜欢使用springBoot自带的注解方式，只用两个注解即可了。

[SouthEast]: https://img-blog.csdn.net/20180116092937462?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2VpeGluXzM5ODAwMTQ0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 1]: https://img-blog.csdn.net/20180116094009928?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2VpeGluXzM5ODAwMTQ0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 2]: https://img-blog.csdn.net/20180116094822858?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2VpeGluXzM5ODAwMTQ0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast