前言
使用springboot开发后台代码的时候,很核心的一个功能是为前端提供接口,那么很可能你会遇到如下问题:
1. 接口里面调用的service层是第三方库或者第三方后台程序,导致访问很慢。
2. 接口需要轮询,或者参数较多的情况下导致返回慢。
本文旨在解决如上的接口返回慢的问题,并给出解决方案与思路。
一、使用Callable+FutureTask 实现多线程并发的方式
该思路是很容易想到的一种可行性方案,因为多线程可以大大提高后台处理速度,而且该方式是JAVA自带的。
思路:
1. 开N个线程
2. 引用callable 封装线程需要执行的task
3. 线程里面调用task,并执行。
4. 收集各线程的结果并返回
@Service
public class FutureTaskByReq {public static List> multiTaskGetReq(String projectid, String versionid) {
//开启多线程
ExecutorService exs = Executors.newFixedThreadPool(10);
List> retList = Collections.synchronizedList(new ArrayList());
try {
//结果集
// List list = new ArrayList();
List>> futureList = new ArrayList>>();
//启动线程池,10个任务固定线程数为5
for (int i = 0; i < version.length; i++) {
FutureTask> futureTask = new FutureTask>(new CallableTask(projectid, versionid));
//提交任务,添加返回,Runnable特性
exs.submit(futureTask);
//Future特性
futureList.add(futureTask);
}
//结果归集
while (futureList.size() > 0) {
Iterator>> iterable = futureList.iterator();
//遍历一遍
while (iterable.hasNext()) {
Future> 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> {
String projectid;
String versionid;
public CallableTask(String projectid, String versionid) {
super();
this.projectid = projectid;
this.versionid = versionid;
}
@Override
public Map call() {
Map 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 map;
private static final Timer timer;
/**
* 初始化
*/
static {
timer = new Timer();
// map = new LRUMap<>();
map = new ConcurrentHashMap<>();
}
/**
* 私有构造函数,工具类不允许实例化
*/
private LRULocalCache() {
}
/**
* 基于LRU策略的map
*
* @param
* @param
*/
static class LRUMap extends LinkedHashMap {
/**
* 读写锁
*/
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 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);
}
}
标签:返回,SpringBoot,接口,static,param,key,new,public,String
来源: https://www.cnblogs.com/Ronaldo-HD/p/11510681.html