多线程缓存优化思想

1.背景
题库 随机生成N张试卷，每张试卷M个题目,每个题目要到 数据库 下载 相应的图片，
而且在N张试卷 的 N*M 个题目中 会存在很多 相同的题目。这就给我们可以设置缓存
大大优化处理速度。

2.多线程优化 N张试卷思想

//生成文档的线程池
private static ExecutorService docMakeService
= Executors.newFixedThreadPool(Consts.THREAD_COUNT_BASE*2);

private static CompletionService docCompletionService
= new ExecutorCompletionService(docMakeService);


//生成文档的线程
private static class MakeDocTask implements Callable<String>{
private PendingDocVo pendingDocVo;

public MakeDocTask(PendingDocVo pendingDocVo) {
this.pendingDocVo = pendingDocVo;
}

@Override
public String call() throws Exception {
long start = System.currentTimeMillis();
String localName = DocService.makeAsyn(pendingDocVo);
System.out.println("文档"+localName+"生成耗时："
+(System.currentTimeMillis()-start)+"ms");
return localName;
}
}


main
for(PendingDocVo doc:docList){
docCompletionService.submit(new MakeDocTask(doc));
}

for(PendingDocVo doc:docList){
Future<String> futureLocalName = docCompletionService.take();
uploadCompletionService.submit(new UploadDocTask(futureLocalName.get()));
}


3.多线程 缓存 优化生成题目 核心思想
1）
//存放处理过题目内容的缓存
private static ConcurrentHashMap<Integer,ProblemCacheVo> problemCache
= new ConcurrentHashMap<Integer,ProblemCacheVo>();
2）
//存放正在处理的题目的缓存，防止多个线程同时处理一个题目
private static ConcurrentHashMap<Integer,Future<ProblemCacheVo>>
processingProblemCache = new ConcurrentHashMap<Integer,Future<ProblemCacheVo>>();

3）
//处理的题目的线程池
private static ExecutorService makeProblemExec =
Executors.newFixedThreadPool(Consts.THREAD_COUNT_BASE*2);

4）
//供调用者使用，返回题目的内容或者任务
public static MultiProblemVo makeProblem(Integer problemId){
//检查缓存中是否存在
ProblemCacheVo problemCacheVo = problemCache.get(problemId);
if(null==problemCacheVo){
//System.out.println("题目【"+problemId+"】在缓存中不存在，需要新启任务");
return new MultiProblemVo(getProblemFuture(problemId));
}else{
//拿摘要，一篇文档中的所有题目的摘要其实可以一次性取得，以减少对数据库的访问
String problemSha = ProblemBank.getProblemSha(problemId);
if(problemCacheVo.getProblemSha().equals(problemSha)){
//System.out.println("题目【"+problemId+"】在缓存中存在且没有修改过，可以直接使用。");
return new MultiProblemVo(problemCacheVo.getProcessedContent());
}
else{
//System.out.println("题目【"+problemId+"】的摘要发生了变化，启动任务更新缓存。");
return new MultiProblemVo(getProblemFuture(problemId));
}
}

}

5）
//返回题目的工作任务
private static Future<ProblemCacheVo> getProblemFuture(Integer problemid){
Future<ProblemCacheVo> problemFuture = processingProblemCache.get(problemid);
if (problemFuture==null){
ProblemDBVo problemDBVo = ProblemBank.getProblem(problemid);
ProblemTask problemTask = new ProblemTask(problemDBVo,problemid);
//当前线程新启了一个任务
FutureTask<ProblemCacheVo> ft =
new FutureTask<ProblemCacheVo>(problemTask);
problemFuture = processingProblemCache.putIfAbsent(problemid,ft);
if (problemFuture==null){
//表示没有别的线程正在处理当前题目
problemFuture = ft;
makeProblemExec.execute(ft);
//System.out.println("题目【"+problemid+"】计算任务启动，请等待完成>>>>>>>>>>>>>。");
}else{
System.out.println("刚刚有其他线程启动了题目【"+problemid+"】的计算任务，任务不必开启");
}
}else{
//System.out.println("当前已经有了题目【"+problemid+"】的计算任务，不必重新开启");
}
return problemFuture;
}

6）
//处理题目的任务
private static class ProblemTask implements Callable<ProblemCacheVo>{

private ProblemDBVo problemDBVo;
private Integer problemId;

public ProblemTask(ProblemDBVo problemDBVo, Integer problemId) {
this.problemDBVo = problemDBVo;
this.problemId = problemId;
}

@Override
public ProblemCacheVo call() throws Exception {
try {
ProblemCacheVo problemCacheVo = new ProblemCacheVo();
problemCacheVo.setProcessedContent(
BaseProblemService.makeProblem(problemId,problemDBVo.getContent()));
problemCacheVo.setProblemSha(problemDBVo.getSha());
problemCache.put(problemId,problemCacheVo);
return problemCacheVo;
} finally {
//无论正常还是异常，都需要将生成的题目的任务从缓存移除
processingProblemCache.remove(problemId);
}
}
}

}


4.核心思想总结
1）存放处理过题目内容的缓存：
如果缓存中存在，就不需要处理，直接返回 题目内容结果；
return new MultiProblemVo(problemCacheVo.getProcessedContent());
缓存不存在，则要开启一个 处理题目的线程。进入3）
return new MultiProblemVo(getProblemFuture(problemId));

2）存放正在处理的题目内容缓存
//存放正在处理的题目的缓存，防止多个线程同时处理一个题目
private static ConcurrentHashMap<Integer,Future<ProblemCacheVo>>
processingProblemCache = new ConcurrentHashMap<Integer,Future<ProblemCacheVo>>();

//处理的题目的线程池
private static ExecutorService makeProblemExec =
Executors.newFixedThreadPool(Consts.THREAD_COUNT_BASE*2);


3）返回题目的工作任务
首先看看 //存放正在处理的题目的缓存，防止多个线程同时处理一个题目 正在出路题目的缓存中有没有
如果有 说明任务已经开启，不需要再重新开启
如果没有，重新创建一个线程任务 然后利用 problemFuture = processingProblemCache.putIfAbsent(problemid,ft);
看看此刻 处理线程任务缓存中有没有任务，
如果problemFuture==null ,表明没有任务正在处理，启动线程 makeProblemExec.execute(ft);
如果有值，说明在刚刚的片刻已经有任务再启动 不需重新启动


5.问题
1）正在内存中处理的任务 是什么时候投放到 缓存的？
在内存中正在处理任务的缓存中判断没有任务，然后创建一个任务 ，然后利用 putIfAbsent 投放到 在内存中处理任务缓存中。注意处理完了 就要移除

2）任务结果是什么时候投放到 题目处理结果缓存的？
在任务处理的线程里，处理完了 就投放到缓存，且还要正在内存中 处理的缓存中移除