前言
使用springboot开发后台代码的时候，很核心的一个功能是为前端提供接口，那么很可能你会遇到如下问题：
1. 接口里面调用的service层是第三方库或者第三方后台程序，导致访问很慢。
2. 接口需要轮询，或者参数较多的情况下导致返回慢。
本文旨在解决如上的接口返回慢的问题，并给出解决方案与思路。
一、使用Callable+FutureTask 实现多线程并发的方式
该思路是很容易想到的一种可行性方案，因为多线程可以大大提高后台处理速度，而且该方式是JAVA自带的。
思路:
1. 开N个线程
2. 引用callable 封装线程需要执行的task
3. 线程里面调用task，并执行。
4. 收集各线程的结果并返回
@Service
public class FutureTaskByReq {public static List<Map<String,Integer>> multiTaskGetReq(String projectid, String versionid) {
//开启多线程
ExecutorService exs = Executors.newFixedThreadPool(10);
List<Map<String,Integer>> retList = Collections.synchronizedList(new ArrayList());
try {
//结果集
// List<Integer> list = new ArrayList<Integer>();
List<FutureTask<Map<String,Integer>>> futureList = new ArrayList<FutureTask<Map<String,Integer>>>();
//启动线程池，10个任务固定线程数为5
for (int i = 0; i < version.length; i++) {
FutureTask<Map<String,Integer>> futureTask = new FutureTask<Map<String,Integer>>(new CallableTask(projectid, versionid));
//提交任务，添加返回，Runnable特性
exs.submit(futureTask);
//Future特性
futureList.add(futureTask);
}
//结果归集
while (futureList.size() > 0) {
Iterator<FutureTask<Map<String,Integer>>> iterable = futureList.iterator();
//遍历一遍
while (iterable.hasNext()) {
Future<Map<String,Integer>> future = iterable.next();
if (future.isDone() && !future.isCancelled()) {
//Future特性
retList.add(future.get());
//任务完成移除任务
iterable.remove();
} else {
//避免CPU高速轮循，可以休息一下。
Thread.sleep(1);
}
}
} // System.out.println("list=" + retList);
// System.out.println("总耗时=" + (System.currentTimeMillis() - start) + ",取结果归集耗时=" + (System.currentTimeMillis() - getResultStart));
} catch (Exception e) {
e.printStackTrace();
} finally {
exs.shutdown();
}return retList;
} /**
* @Description 回调方法
*/
public static class CallableTask implements Callable<Map<String,Integer>> {
String projectid;
String versionid; public CallableTask(String projectid, String versionid) {
super();
this.projectid = projectid;
this.versionid = versionid;
} @Override
public Map<String,Integer> call() {
Map<String,Integer> retmap=new HashMap<>();
//你想要执行的task
return retmap;
} }
二、使用定时任务+缓存的方式解决接口返回慢的问题
思路与场景： 有些接口的访问量不大，或者请求的数据变动不频繁，可以暂时存放到缓存，例如redis里面。那么获取的时候就是即时获取。
springboot自带了 @EnableScheduling 注解，可以执行定时任务。采用cron 表达式即可精准定时执行。
Redis 则有大量的缓存策略与算法，这里推荐使用LRU算法进行存取都很方便。
定时部分：
@Component
@Configuration //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling // 2.开启定时任务
public class LocalSchedule { //添加定时任务,每天12点定时执行
@Scheduled(cron = "0 0 12 * * ?" )
//或直接指定时间间隔，例如：5秒
//@Scheduled(fixedRate=5000)
private void configureTasks() {
//TODO 需要执行的定时任务，主要是比较慢的接口 System.err.println("执行静态1定时任务时间: " + LocalDateTime.now());
}
}
LRU算法：
/**
* 使用LRU策略进行一些数据缓存。
*/
public class LRULocalCache { /**
* 默认有效时长,单位:秒
*/
private static final long DEFUALT_TIMEOUT = ;private static final Map<String, Object> map; private static final Timer timer; /**
* 初始化
*/
static {
timer = new Timer();
// map = new LRUMap<>();
map = new ConcurrentHashMap<>();
} /**
* 私有构造函数,工具类不允许实例化
*/
private LRULocalCache() { } /**
* 基于LRU策略的map
*
* @param <K>
* @param <V>
*/
static class LRUMap<K, V> extends LinkedHashMap<K, V> { /**
* 读写锁
*/
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); private final Lock rLock = readWriteLock.readLock(); private final Lock wLock = readWriteLock.writeLock(); /**
* 默认缓存容量
*/
private static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; /**
* 默认最大缓存容量
*/
// private static final int DEFAULT_MAX_CAPACITY = 1 << 30;
private static final int DEFAULT_MAX_CAPACITY = 1 << 18; /**
* 加载因子
*/
private static final float DEFAULT_LOAD_FACTOR = 0.75f; public LRUMap() {
super(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
} public LRUMap(int initialCapacity) {
super(initialCapacity, DEFAULT_LOAD_FACTOR);
} public void clear() {
wLock.lock();
try {
super.clear();
} finally {
wLock.unlock();
}
} /**
* 重写LinkedHashMap中removeEldestEntry方法;
* 新增元素的时候,会判断当前map大小是否超过DEFAULT_MAX_CAPACITY,超过则移除map中最老的节点;
*
* @param eldest
* @return
*/
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > DEFAULT_MAX_CAPACITY;
} } /**
* 清除缓存任务类
*/
static class CleanWorkerTask extends TimerTask { private String key; public CleanWorkerTask(String key) {
this.key = key;
} public void run() {
map.remove(key);
}
} /**
* 增加缓存
*
* @param key
* @param value
*/
public static void add(String key, Object value) {
map.put(key, value);
timer.schedule(new CleanWorkerTask(key), DEFUALT_TIMEOUT); } /**
* 增加缓存
*
* @param key
* @param value
* @param timeout 有效时长
*/
public static void put(String key, Object value, int timeout) {
map.put(key, value);
timer.schedule(new CleanWorkerTask(key), timeout * SECOND_TIME);
} /**
* 增加缓存
*
* @param key
* @param value
* @param expireTime 过期时间
*/
public static void put(String key, Object value, Date expireTime) {
map.put(key, value);
timer.schedule(new CleanWorkerTask(key), expireTime);
}
/**
* 获取缓存
*
* @param key
* @return
*/
public static Object get(String key) {
return map.get(key);
}
}