java多线程查询

由于最近工作遇到性能问题，尝试研究用多线程来实现，结果速度快了好几倍

下面是多线程查询的部分代码，提供给大家参考下：

线程类：

带返回值的类要实现Callable接口，具体业务逻辑没有实现，只是写了个空方法在里面

package com.sanfy.demo.thread;

import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;

import com.sanfy.demo.model.WorkLoad;

public class QueryThread implements Callable<List<WorkLoad>> {
   
   private List<WorkLoad> workLoads;
   private WorkLoadService workLoadService;
   private Map<String, Object> parameters;
   private List<String> dates;
   private int begin;
   private int end;
  
    public QueryThread(Map<String, Object> parameters,List<String> dates, int begin, int end,WorkLoadService workLoadService) {
        super();
        this.parameters = parameters;
        this.dates = dates;
        this.begin = begin;
        this.end = end;
        this.workLoadService=workLoadService;

    }
   
    /**
     * @return Map<Integer, EchartsTenInDatasDTO>
     * @see java.lang.Callable#call()
     */
   
    @Override
    public Map<Integer, WorkLoad> call() {
        for (int i = begin; i < end; i++) {
            queryListByMap(dates.get(i));
        }
        return workLoads;
    }
   
    /**
     * 查询方法
     *
     * @param date 日期
     * @param i i
     */
    private void queryListByMap(String date) {
       //具体的查询
     workLoads=workLoadService.queryList(parameters,date);
    }

 public List<WorkLoad> getWorkLoads() {
  return workLoads;
 }

 public void setWorkLoads(List<WorkLoad> workLoads) {
  this.workLoads = workLoads;
 }

 public WorkLoadService getWorkLoadService() {
  return workLoadService;
 }

 public void setWorkLoadService(WorkLoadService workLoadService) {
  this.workLoadService = workLoadService;
 }

 public Map<String, Object> getParameters() {
  return parameters;
 }

 public void setParameters(Map<String, Object> parameters) {
  this.parameters = parameters;
 }

 public List<String> getDates() {
  return dates;
 }

 public void setDates(List<String> dates) {
  this.dates = dates;
 }

 public int getBegin() {
  return begin;
 }

 public void setBegin(int begin) {
  this.begin = begin;
 }

 public int getEnd() {
  return end;
 }

 public void setEnd(int end) {
  this.end = end;
 }
   
   
   
}

 

serive调用线程类来实现多线程查询：

package com.sanfy.demo.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import com.sanfy.demo.model.WorkLoad;

public class QuerySerivce {

 private WorkLoadService workLoadService;
 
  public List<WorkLoad> queryListsByMap(String sqlCode, Map<String, Object> parameters) throws Exception {
   List<WorkLoad> workLoads=new ArrayList<WorkLoad>();
         long startTime = System.currentTimeMillis();
         List<String> dates = DateUtil.getCurrentInYear(parameters.get("startDate").toString(), 12);
         if (dates != null && dates.size() > 0) {
             int len = dates.size();
             // 创建线程的个数
             int count = len % 2 == 0 ? len / 2: (len / 2) + 1;
             // 创建线程池数量
             ExecutorService pool = Executors.newFixedThreadPool(count);
             List<Callable<List<WorkLoad>>> tasks = new ArrayList<Callable<List<WorkLoad>>>();
             for (int i = 0; i < count; i++) {
                 // 每个线程负责插入数据的开始位置
                 int start = i * 2;
                 // 每个线程负责插入数据的结束位置
                 int end = i == count - 1 ? i * 2 + (len - i * 2) : i* 2+ 2;
                 Map<String, Object> parametersClone = new HashMap<String, Object>();
                 parametersClone.putAll(parameters);
                 // 线程返回值
                 Callable<List<WorkLoad>> task = new QueryThread(parametersClone, sqlCode, dates, start, end,workLoadService);
                 tasks.add(task);
             }
             // 执行线程
             List<Future<List<WorkLoad>>> futures = pool.invokeAll(tasks);
             // 处理线程返回结果
             if (futures != null && futures.size() > 0) {
                 for (Future<List<WorkLoad>> future : futures) {
                     workLoads.addAll(future.get());
                 }
             }
             // 关闭线程池
             pool.shutdown();
         }
         long endTime = System.currentTimeMillis();
         logger.info("多个情况报表查询总共花了:" + (endTime - startTime) / 1000 + "秒时间!");
         return workLoads;
     }
    
}

 后续会补上多线程批量保存与android多线程支持断点续传下载的内容

由于是实际项目，所以把具体的内容删除了，直接修改的，供大家参考下