一、异步与同步
- 异步调用：程序在顺序执行时，不等待异步调用的语句返回结果就执行后面的程序；
- 同步调用：程序按照定义顺序依次执行，每行代码必须等待上一行程序执行完才能执行；
下面我们通过代码详细比较同步与异步的差异
同步调用
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Random;
/**
* 同步信息
*
* @author <a href="jian.huang@bintools.cn">yunzhe</a>
* @version 1.0.0 2019-07-09-下午8:45
*/
@Component
@Slf4j
public class SyncTask {
public static Random random = new Random();
public void doTaskOne() throws InterruptedException {
log.info("sync开始任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("sync完成任务一、耗时："+(end-start)+"毫秒");
}
public void doTaskTwo() throws InterruptedException {
log.info("sync开始任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("sync完成任务二、耗时："+(end-start)+"毫秒");
}
public void doTaskThree() throws InterruptedException {
log.info("sync开始任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("sync完成任务三、耗时："+(end-start)+"毫秒");
}
}
执行结果；
syncTask.jpg
异步处理
- 1 创建连接池
/***
* 创建线程池
*/
@EnableAsync
@Configuration
class TaskPoolConfig{
@Bean("taskExecutor")
public Executor taskExecutor(){
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
return executor;
}
}
- 2 异步处理
import java.util.Random;
/**
* 异步处理
*
* @author <a href="jian.huang@bintools.cn">yunzhe</a>
* @version 1.0.0 2019-07-09-上午11:19
*/
@Slf4j
@Component
public class Task {
public static Random random = new Random();
@Async("taskExecutor")
public void doTaskOne() throws InterruptedException {
log.info("开始任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务一、耗时："+(end-start)+"毫秒");
}
@Async("taskExecutor")
public void doTaskTwo() throws InterruptedException {
log.info("开始任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务二、耗时："+(end-start)+"毫秒");
}
@Async("taskExecutor")
public void doTaskThree() throws InterruptedException {
log.info("开始任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务三、耗时："+(end-start)+"毫秒");
}
}
-
3 执行结果
task.jpg
异步回调
有时我们需要对异步调用的结果进行相关的处理，此时需要进行相应的回掉。具体操作如下：
/***
*
*/
@Component
@Slf4j
public class AsyncTask {
@Async("taskExecutor")
public Future<String> doTask() throws InterruptedException {
log.info("Task1 started");
long start = System.currentTimeMillis();
Thread.sleep(5000);
long end = System.currentTimeMillis();
log.info("Task1 finished,time elapsed:{} ms",end-start);
return new AsyncResult<>("Task1 accomplished");
}
@Async("taskExecutor")
public Future<String> doTask2() throws InterruptedException {
log.info("Task2 started");
long start = System.currentTimeMillis();
Thread.sleep(3000);
long end = System.currentTimeMillis();
log.info("Task2 finished,time elapsed:{} ms",end-start);
return new AsyncResult<>("Task2 accomplished");
}
}
异步回调结果在单元测试的主类中
单元测试
package com.example.springbootasync;
import com.example.springbootasync.sync.SyncTask;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class SpringbootasyncApplicationTests {
@Autowired
private Task task;
@Autowired
private AsyncTask asyncTask;
@Autowired
private SyncTask syncTask;
@Test
public void syncTaskTest() throws InterruptedException {
syncTask.doTaskOne();
syncTask.doTaskTwo();
syncTask.doTaskThree();
}
@Test
public void contextLoads() throws InterruptedException {
task.doTaskOne();
task.doTaskTwo();
task.doTaskThree();
Thread.currentThread().join();
}
@Test
public void AsyncTaskTest() throws InterruptedException, ExecutionException {
Future<String> task1 = asyncTask.doTask();
Future<String> task2 = asyncTask.doTask2();
while(true){
if(task1.isDone() && task2.isDone()){
log.info("TASK1 result: {}",task1.get());
log.info("TASK2 result: {}",task2.get());
break;
}
Thread.sleep(1000);
}
log.info("All tasks finished.");
}
}
总结
通过以上操作，我们对同步与异步进行了一定的了解。通过代码对异步回调有初步的认识。但是在一些具体的业务场景中如何处理，需要进行相应的场景修改。
码云地址：https://gitee.com/huangjian163/springbootSync.git
