【总结】ITOO在线编辑性能优化——多线程

迷南。 2022-09-23 08:51 236阅读 0赞

#    项目背景 #

![Center][]  ![Image 1][]![Image 1][]

#  ![Center 1][]     #

# 问题： #

由上图可以知道，“页面需要根据试卷id获取全部的试卷信息”，由下面代码可以看出根据返回的“returnPaperDetail”进行开始进行嵌套循环操作。

图解：

![Image 1][]![Center 2][]

具体代码如下

/** 
       
        * 功能：queryAllQuestion 
       
        * 描述：加载页面查询出所有表的数据 
       
        * 主要实体：ExaminationPaper（4张表的联合：questionMain，questionSub,paperMain,paperSub） 
       
        * 作者:十一期 谭倩倩 
       
        * 时间：2016-6-18 
       
        * 修改人： 
       
        * 修改时间： 
       
        * @param request 
       
        * @param response 
       
        */ 
       
        @RequestMapping("/queryAllQuestion") 
       
        public void queryAllQuestion(HttpServletRequest request,HttpServletResponse response) 
       
        { 
       
        //1.抽取paperMain 
       
        ExaminationPaper examinationPaper=new ExaminationPaper(); 
       
        String paperMainId=paperId.replace("'", "");//暂时使用假数据 
       
        String dataBaseName="itoo_exam"; 
       
        PaperMain RepaperMain=paperMainBean.queryPaperMainById(paperMainId, dataBaseName); 
       
        examinationPaper.setId(paperMainId); 
       
        examinationPaper.setPaperName(RepaperMain.getComment()); 
       
        examinationPaper.setPaperScore(RepaperMain.getScore()); 
       
        //2. 抽取paperdetail和questionMain数据（嵌套循环） 
       
        
       
        List<PaperDetail> returnPaperDetail=this.ReturnqueryPaperDetail(paperMainId, dataBaseName); 
       
        List<QuestionMain> RequestionMainList=new ArrayList<QuestionMain>(); 
       
        List<QuestionSub> RequestionSubList=new ArrayList<QuestionSub>(); 
       
        
       
        
       
        //循环paperdetail 
       
        for (PaperDetail returnSinglePaperDetail : returnPaperDetail) 
       
        { 
       
        RequestionMainList=this.ReturnQuestionMain(returnSinglePaperDetail.getId(), dataBaseName); 
       
        
       
        RequestionMainList = orderByQuestionMainList(RequestionMainList); 
       
        for (QuestionMain returnSinglequestionMain : RequestionMainList) 
       
        { 
       
        RequestionSubList=this.ReturnQuestionSub(returnSinglequestionMain.getId(), dataBaseName); 
       
        returnSinglequestionMain.setOptions(RequestionSubList); 
       
        } 
       
        
       
        //查询出来的组件 
       
        List<QuestionTypeDetail> lstQuestionTypeDetail = paperMainBean.queryComponentById( 
       
        returnSinglePaperDetail.getQuestionTypeId(), dataBaseName); 
       
        returnSinglePaperDetail.setLstQuestionTypeDetail(lstQuestionTypeDetail); 
       
        
       
        //把组件的英文名称装到“returnSinglePaperDetail”里面 
       
        
       
        returnSinglePaperDetail.setLstQuestionMain(RequestionMainList); 
       
          
       
        } 
       
        examinationPaper.setPaperDetails(returnPaperDetail); 
       
        jacksonJson.beanToJson(response, examinationPaper); 
       
        } 
       
          
       
        /** 
       
        * @param RequestionMainList 
       
        * @return 
       
        */ 
       
        private List<QuestionMain> orderByQuestionMainList( 
       
        List<QuestionMain> RequestionMainList) { 
       
        /**对大小题进行排序思路： 
       
        // * ①定义一个 List<QuestionMain> bigLittleQuestion 用于存放排好序的大小题。 
       
        // * ②判断查出来的题型是大小题，则先筛选大题。 
       
        // * ③如果是大题，将其放到bigLittleQuestion中。 
       
        // * 然后遍历所有题目，找到该大题对应的所有小题。放到bigLittleQuestion中。 
       
        // * 
       
        // * 
       
        // */ 
       
        ……………………………………………………………… 
       
        }

# 【解决方案】 #

一套试卷有多个题型，那么我就设置每个题型为一个线程。

图示：

![Center 3][]

![Image 1][]

代码如下：

大体是实例化一个线程池，根据题目数量的多少来添加多少个线程，一个题型代表一个线程，最后遍历线程结果。

public void queryAllQuestion(HttpServletRequest request,HttpServletResponse response) 
       
        { 
       
        //1.抽取paperMain 
       
        ExaminationPaper examinationPaper=new ExaminationPaper(); 
       
        String paperMainId=paperId.replace("'", "");//暂时使用假数据 
       
        String dataBaseName="itoo_exam"; 
       
        PaperMain RepaperMain=paperMainBean.queryPaperMainById(paperMainId, dataBaseName); 
       
        examinationPaper.setId(paperMainId); 
       
        examinationPaper.setPaperName(RepaperMain.getComment()); 
       
        examinationPaper.setPaperScore(RepaperMain.getScore()); 
       
        //2. 抽取paperdetail和questionMain数据（嵌套循环） 
       
        List<PaperDetail> returnPaperDetail=this.ReturnqueryPaperDetail(paperMainId, dataBaseName); 
       
        
       
        //测试加上线程的时间 
       
        long startTime=System.currentTimeMillis(); 
       
        int count=returnPaperDetail.size(); 
       
        
       
        //创建一个线程池 
       
        ExecutorService executorService = Executors.newCachedThreadPool(); 
       
        List<Future<PaperDetail>> resultList = new ArrayList<Future<PaperDetail>>(); 
       
        for (PaperDetail returnSinglePaperDetail : returnPaperDetail) { 
       
        //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中 
       
        Future<PaperDetail> future = executorService.submit(new myCallable(returnSinglePaperDetail)); 
       
        //将任务执行结果存储到List中 
       
        resultList.add(future); 
       
        } 
       
        List<PaperDetail> listPapaerDeatil=new ArrayList<PaperDetail>(); 
       
        
       
        //遍历任务的结果 
       
        for (Future<PaperDetail> fp: resultList) { 
       
        try { 
       
        PaperDetail enPaperDetail =fp.get(); 
       
        listPapaerDeatil.add(enPaperDetail); 
       
        } catch (InterruptedException | ExecutionException e) { 
       
        // TODO Auto-generated catch block 
       
        e.printStackTrace(); 
       
        } 
       
        
       
        //启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。 
       
        executorService.shutdown(); 
       
        } 
       
        
       
        examinationPaper.setPaperDetails(listPapaerDeatil); 
       
        long endTime=System.currentTimeMillis(); 
       
        System.out.println(endTime-startTime); 
       
          
       
        jacksonJson.beanToJson(response, examinationPaper); 
       
        }

/** 
        
         * 多线程进行题干和选项查询。 
        
         * @author 十一期 谭倩倩 
        
         * 
        
         */ 
        
         @SuppressWarnings("unchecked") 
        
         public class myCallable implements Callable<PaperDetail>{ 
        
         private PaperDetail paperDetail; 
        
         public myCallable(PaperDetail paperDetail) { 
        
         this.paperDetail = paperDetail; 
        
         } 
        
         String dataBaseName="itoo_exam"; 
        
         public PaperDetail call(){ 
        
         List<QuestionMain> RequestionMainList=questionMainBean.queryQuestionbankList(paperDetail.getId(), dataBaseName); 
        
         
        
         RequestionMainList = orderByQuestionMainList(RequestionMainList); 
        
         for (QuestionMain returnSinglequestionMain : RequestionMainList) 
        
         { 
        
         
        
         List<QuestionSub> RequestionSubList=questionSubBean.queryQuestionbankOptionsList(returnSinglequestionMain.getId(), dataBaseName); 
        
         returnSinglequestionMain.setOptions(RequestionSubList); 
        
         
        
         } 
        
         
        
         //查询出来的组件 
        
         List<QuestionTypeDetail> lstQuestionTypeDetail = paperMainBean.queryComponentById( 
        
         paperDetail.getQuestionTypeId(), dataBaseName); 
        
         paperDetail.setLstQuestionTypeDetail(lstQuestionTypeDetail); 
        
         
        
         //把组件的英文名称装到“returnSinglePaperDetail”里面 
        
         
        
         paperDetail.setLstQuestionMain(RequestionMainList); 
        
         return paperDetail; 
        
         
        
         } 
        
         }

# 【结果】 #

没有用线程的结果是：

（第一套测试卷子）

![Center 4][]

![Image 1][]

（第二套测试卷子）

![Center 5][]

![Image 1][]

用了线程的结果是：

（第一套测试卷子）

![Center 6][]

![Image 1][]

（第二套测试卷子）

![Image 1][]

![Center 7][]

# 【总结】 #

还需要优化的性能：

##       1. 算法优化 ##

（需要优化的代码）

private List<QuestionMain> orderByQuestionMainList( 
       
        List<QuestionMain> RequestionMainList) { 
       
        /**对大小题进行排序思路： 
       
        // * ①定义一个 List<QuestionMain> bigLittleQuestion 用于存放排好序的大小题。 
       
        // * ②判断查出来的题型是大小题，则先筛选大题。 
       
        // * ③如果是大题，将其放到bigLittleQuestion中。 
       
        // * 然后遍历所有题目，找到该大题对应的所有小题。放到bigLittleQuestion中。 
       
        // * 
       
        // * 仍需要优化 
       
        // */ 
       
        if (RequestionMainList!=null && RequestionMainList.size()>1 ) 
       
        { 
       
        
       
        if ( RequestionMainList.get(0).getIsParentQuestion()==1 || RequestionMainList.get(0).getParentQuestionId()!=null) 
       
        { //筛选是大小题 
       
        List<QuestionMain> bigLittleQuestion=new ArrayList<QuestionMain>(); 
       
        
       
        for (int i = 0; i < RequestionMainList.size(); i++) 
       
        { 
       
        if (RequestionMainList.get(i).getIsParentQuestion()==1) 
       
        { //查找出所有的大题干 
       
        bigLittleQuestion.add(RequestionMainList.get(i)); 
       
        //查找该大题干下面所有的小题干 
       
        for (int j = 0; j < RequestionMainList.size(); j++) 
       
        { 
       
        //匹配该大题干下面的小题干 
       
        if(RequestionMainList.get(j).getParentQuestionId()!=null) 
       
        { 
       
        if (RequestionMainList.get(j).getParentQuestionId().equals(RequestionMainList.get(i).getId())) 
       
        { 
       
        bigLittleQuestion.add(RequestionMainList.get(j)); 
       
        } 
       
        } 
       
        } 
       
        
       
        
       
        } 
       
        } 
       
        RequestionMainList=bigLittleQuestion; 
       
        } 
       
        } 
       
        return RequestionMainList; 
       
        }

##       2. 批量查询或者缓存 ##

（需要优化的代码）

for (QuestionMain returnSinglequestionMain : RequestionMainList) 
       
        { 
       
        
       
        List<QuestionSub> RequestionSubList=questionSubBean.queryQuestionbankOptionsList(returnSinglequestionMain.getId(), dataBaseName);

[Center]: https://img-blog.csdn.net/20160716215538728?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Image 1]: 
[Center 1]: /images/20220720/63f712eb37014529ba38a0c834d93d51.png
[Center 2]: /images/20220720/0704d0347aee42148ef69c5efe9113a0.png
[Center 3]: /images/20220720/b5ebc9b14aef4d4a86a19a4724553d51.png
[Center 4]: /images/20220720/ecf5f181d7b44d71a2f8168d646c9e85.png
[Center 5]: /images/20220720/f11a6f63696a492b9ddc7710ebf54412.png
[Center 6]: /images/20220720/715e1fc27f78400094804760e0f86090.png
[Center 7]: /images/20220720/53486fd4eb174b97bdcd50f0dc70b16c.png