线程池的应用

在项目中，应用到了线程池，将代码记录下来，以便将来查看。

1.获取案件信息列表   （controller中的方法  由其他方法调用）

 public List<CaseInfo> getCaseInfoList(JSONArray jsonArray) {
        List<CaseInfo> resultList = new ArrayList<>();
        try {
            // 每30条数据开启一条线程
            int threadSize = 30;
            // 总数据条数
            int dataSize = jsonArray.size();
            // 线程数
            int threadNum = dataSize / threadSize + 1;
            // 定义标记,过滤threadNum为整数
            boolean special = dataSize % threadSize == 0;

            List<Object> jsonList = null;
            //创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
//定义返回参数   真正的返回的参数类型是  List<CaseInfo> 被Future封装了一层   由于返回的参数不止一个 所以放到list中
            List<Future<List<CaseInfo>>> futures = new ArrayList<>();
//            循环   将数据按照上述要求 以30个为一组放到线程中
            for (int i = 0; i < threadNum; i++) {
                if (i == threadNum - 1) {
                    if (special) {
                        break;
                    }
                    jsonList = jsonArray.subList(threadSize * i, dataSize);
                } else {
                    jsonList = jsonArray.subList(threadSize * i, threadSize * (i + 1));
                }
                final List<Object> objectList = jsonList;
                Callable<List<CaseInfo>> caseInfoCallable = new Callable<List<CaseInfo>>() {
//                    重写call()方法   定义返回类型为List<CaseInfo>
                    @Override
                    public List<CaseInfo> call() {
                        List<CaseInfo> caseInfoList = new ArrayList<>();
                        for (Object object : objectList) {
                            JSONObject jsonObject = JSONObject.parseObject(object.toString());
                            // 返回的案件ID
                            String id = jsonObject.getString("ID");
                            String caseBasis = jsonObject.getString("SIM_COMMON_PROPS");
                            CaseInfo caseInfo = caseInfoService.findCaseInfoById(id);
                            if (null != caseInfo) {
                                caseInfo.setCaseBasis(caseBasis);
                                caseInfoList.add(caseInfo);
                            }
                        }
                        return caseInfoList;
                    }
                };
//                线程提交数据   submit()方法一提交就立刻产生Future类型的返回值，但是刚刚提交的任务可能还在线程池的任务队列中排队
                futures.add(executorService.submit(caseInfoCallable));
            }
            for (Future<List<CaseInfo>> future : futures) {
                List<CaseInfo> caseInfoList = null;
//get()方法取出  Future中的 List<CaseInfo>对象
// 由于submit()的伪返回，所以当任务还在线程池中排队时用get()获取返回值时，get()所在的线程将会阻塞  直到submit提交的任务再线程池中真正执行
                caseInfoList = future.get();
                if (null != caseInfoList && caseInfoList.size() > 0) {
                    resultList.addAll(caseInfoList);
                }
            }
//            关闭线程池
            executorService.shutdown();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return resultList;
    }

2. 获取单个案件信息（由jsp页面直接调用）

@ResponseBody
    @RequestMapping(value = "caseInfoMessage", method = RequestMethod.POST)
    public TableModel caseInfoMessage(String id, String caseDesc) {
        String url = "";
        String result = "";
        String dictKey = "";
        String predicted = "";
        Future future = null;
        Callable callable = null;
        ExecutorService pool = null;
        TableModel tableModel = new TableModel();
        tableModel.setTotal(0);
        try {
            int taskSize = 3;
//            创建线程池
            pool = Executors.newFixedThreadPool(taskSize);
            // 文本提取
            url = PropertiesUtils.getValue("caseDescTextUrl");
            logger.info(">>>文本提取:" + url);
            if (StringUtils.isNotEmpty(url)) {
                callable = new CaseInfoController(url, caseDesc, 1);
                future = pool.submit(callable);
                result = future.get().toString();
                if (StringUtils.isNotEmpty(result)) {
                    JSONObject fromTextJson = JSONObject.parseObject(result);
                    // 账户
                    String account = fromTextJson.getString("account");
                    if (StringUtils.isNotEmpty(account)) {
                        this.modifyCaseInfo(id, account, 9);
                    }
                    // 电话
                    String phone = fromTextJson.getString("phone");
                    if (StringUtils.isNotEmpty(phone)) {
                        this.modifyCaseInfo(id, phone, 10);
                    }
                    // 网络
                    String network = fromTextJson.getString("network");
                    if (StringUtils.isNotEmpty(network)) {
                        this.modifyCaseInfo(id, network, 11);
                    }
                }
            }
            // 标识提取
            url = PropertiesUtils.getValue("caseDescDictUrl");
            logger.info(">>>标识提取:" + url);
            if (StringUtils.isNotEmpty(url)) {
                // 专案标识
                Map map = new HashMap();
                JSONArray jsonArray = new JSONArray();
                JSONObject jsonObject = new JSONObject();
                callable = new CaseInfoController(url, caseDesc, 2);
                future = pool.submit(callable);
                result = future.get().toString();
                if (StringUtils.isNotEmpty(result)) {
                    map = new HashMap();
                    map.put("root_key", "ZABSDM");
                    jsonArray = JSONArray.parseArray(result);
                    jsonObject = jsonArray.getJSONObject(0);
                    predicted = jsonObject.get("predicted").toString();
                    map.put("dict_value1", predicted);
                    // 专案标识一
                    dictKey = dictService.findDictKeyByMap(map);
                    logger.info(">>>专案标识:"+predicted +",字典：" +dictKey);
                    if (StringUtils.isNotEmpty(dictKey)) {
                        this.modifyCaseInfo(id, dictKey, 5);
                    }
                }
                // 小类标识
                callable = new CaseInfoController(url, caseDesc, 3);
                future = pool.submit(callable);
                result = future.get().toString();
                if (StringUtils.isNotEmpty(result)) {
                    map = new HashMap();
                    map.put("root_key", "AJXLDM");
                    map.put("parent_key", dictKey);
                    jsonArray = JSONArray.parseArray(result);
                    jsonObject = jsonArray.getJSONObject(0);
                    predicted = jsonObject.get("predicted").toString();
                    map.put("dict_value1", predicted);
                    dictKey = dictService.findDictKeyByMap(map);
                    logger.info(">>>小类标识:"+predicted +",字典：" +dictKey);
                    // 小类标识一
                    if (StringUtils.isNotEmpty(dictKey)) {
                        this.modifyCaseInfo(id, dictKey, 6);
                    }
                }
            }
            tableModel = caseInfoService.findCaseInfListById(id);
        } catch (Exception e) {
            logger.error("自动提取服务异常" + e.getMessage());
            throw new DzptWebLayerException("自动提取服务异常", e);
        } finally {
            // 关闭线程池
            if (null != pool) {
                pool.shutdown();
            }
        }
        return tableModel;
    }