Java多线程工具类的使用方法

该多线程处理工具，只需要实现自己的业务逻辑就可以正常使用

主要是针对大数据量list，将list划分多个线程处理的场景

第一步： ResultBean类，返回结果统一bean

package com.HM.eis.commons.multiThread;
import java.io.Serializable;
import com.alibaba.fastjson.JSON;
/**
 * 返回结果统一bean
 */
public class ResultBean<T> implements Serializable {
    private static final long serialVersionUID = 1L;   
    // 成功状态
    public static final int SUCCESS = 1;
    // 处理中状态
    public static final int PROCESSING = 0;
    // 失败状态
    public static final int FAIL = -1;
    // 描述
    private String msg = "success";
    // 状态默认成功
    private int code = SUCCESS;
    // 备注
    private String remark;
    // 返回数据
    private T data;
    public ResultBean() {
        super();
    }
    public ResultBean(T data) {
        super();
        this.data = data;
    }
    /**
     * 使用异常创建结果
     */
    public ResultBean(Throwable e) {
        super();
        this.msg = e.toString();
        this.code = FAIL;
    }    
    /**
     * 实例化结果默认成功状态<BR>
     * 方法名：newInstance<BR>
     */
    public static <T> ResultBean<T> newInstance() {
        ResultBean<T> instance = new ResultBean<T>();
        //默认返回信息
        instance.code = SUCCESS;
        instance.msg = "success";
        return instance;
    }    
    /**
     * 实例化结果默认成功状态和数据<BR>
     * 方法名：newInstance<BR>
     */
    public static <T> ResultBean<T> newInstance(T data) {
        ResultBean<T> instance = new ResultBean<T>();
        //默认返回信息
        instance.code = SUCCESS;
        instance.msg = "success";
        instance.data = data;
        return instance;
    }    
    /**
     * 实例化返回结果<BR>
     * 方法名：newInstance<BR>
     */
    public static <T> ResultBean<T> newInstance(int code, String msg) {
        ResultBean<T> instance = new ResultBean<T>();
        //默认返回信息
        instance.code = code;
        instance.msg = msg;
        return instance;
    }    
    /**
     * 实例化返回结果<BR>
     * 方法名：newInstance<BR>
     */
    public static <T> ResultBean<T> newInstance(int code, String msg, T data) {
        ResultBean<T> instance = new ResultBean<T>();
        //默认返回信息
        instance.code = code;
        instance.msg = msg;
        instance.data = data;
        return instance;
    }    
    /**
     * 设置返回数据<BR>
     * 方法名：setData<BR>
     */
    public ResultBean<T> setData(T data){
        this.data = data;
        return this;
    }    
    /**
     * 设置结果描述<BR>
     * 方法名：setMsg<BR>
     */
    public ResultBean<T> setMsg(String msg){
        this.msg = msg;
        return this;
    }    
    /**
     * 设置状态<BR>
     * 方法名：setCode<BR>
     */
    public ResultBean<T> setCode(int code){
        this.code = code;
        return this;
    }    
    /**
     * 设置备注)<BR>
     * 方法名：setRemark<BR>
     */
    public ResultBean<T> setRemark(String remark){
        this.remark = remark;
        return this;
    }    
    /**
     * 设置成功描述和返回数据<BR>
     * 方法名：success<BR>
     */
    public ResultBean<T> success(String msg, T data){ 
        this.code = SUCCESS;
        this.data = data;
        this.msg = msg;
        return this;  
    }     
    /**
     * 设置成功返回结果描述<BR>
     * 方法名：success<BR>
     */
    public ResultBean<T> success(String msg){ 
        this.code = SUCCESS;
        this.msg = msg;
        return this;  
    }    
    /**
     * 设置处理中描述和返回数据<BR>
     * 方法名：success<BR>
     */
    public ResultBean<T> processing(String msg, T data){ 
        this.code = PROCESSING;
        this.data = data;
        this.msg = msg;
        return this;  
    }     
    /**
     * 设置处理中返回结果描述<BR>
     * 方法名：success<BR>
     */
    public ResultBean<T> processing(String msg){ 
        this.code = PROCESSING;
        this.msg = msg;
        return this;  
    }    
    /**
     * 设置失败返回描述和返回数据<BR>
     * 方法名：fail<BR>
     */
    public ResultBean<T> fail(String msg, T data){ 
        this.code = FAIL;
        this.data = data;
        this.msg = msg;
        return this;  
    }     
    /**
     * 设置失败返回描述<BR>
     * 方法名：fail<BR>
     */
    public ResultBean<T> fail(String msg){ 
        this.code = FAIL;
        this.msg = msg;
        return this;  
    }    
    public T getData() {  
        return data;  
    }  
    public String getMsg() {  
        return msg;  
    }  
    public int getCode() {  
        return code;  
    }  
    public String getRemark() {  
        return remark;  
    }      
    /**
     * 生成json字符串<BR>
     * 方法名：json<BR>
     */
    public String json(){
        return JSON.toJSONString(this);
    }
}

第二步 ：ITask接口： 实现自己的业务

package com.HM.eis.commons.multiThread;
import java.util.Map;
/**
 * 任务处理接口
 * 具体业务逻辑可实现该接口
 *  T 返回值类型
 *  E 传入值类型
 */
public interface ITask<T, E> {    
    /**
     * 任务执行方法接口<BR>
     * 方法名：execute<BR>
     * @param e 传入对象
     * @param params 其他辅助参数
     * @return T<BR> 返回值类型
     */
    T execute(E e, Map<String, Object> params);
}

第三步 ： HandleCallable类： 实现Callable接口，来处理任务

package com.HM.eis.commons.multiThread;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * @ClassName: HandleCallable.java
 * @Description: 线程调用
 */
@SuppressWarnings("rawtypes")
public class HandleCallable<E> implements Callable<ResultBean> {
    private static Logger logger = LoggerFactory.getLogger(HandleCallable.class);
    // 线程名称 
    private String threadName = "";
    // 需要处理的数据
    private List<E> data;
    // 辅助参数
    private Map<String, Object> params;
    // 具体执行任务
    private ITask<ResultBean<Object>, E> task;
    public HandleCallable(String threadName, List<E> data, Map<String, Object> params,
            ITask<ResultBean<Object>, E> task) {
        this.threadName = threadName;
        this.data = data;
        this.params = params;
        this.task = task;
    }
    @Override
    public ResultBean<List<ResultBean<Object>>> call() throws Exception {
        // 该线程中所有数据处理返回结果
        ResultBean<List<ResultBean<Object>>> resultBean = ResultBean.newInstance();
        if (data != null && data.size() > 0) {
            logger.info("线程：{},共处理:{}个数据，开始处理......", threadName, data.size());
            // 返回结果集
            List<ResultBean<Object>> resultList = new ArrayList<>();
            // 循环处理每个数据
            for (int i = 0; i < data.size(); i++) {
                // 需要执行的数据
                E e = data.get(i);
                // 将数据执行结果加入到结果集中
                resultList.add(task.execute(e, params));
                logger.info("线程：{},第{}个数据，处理完成", threadName, (i + 1));
            }
            logger.info("线程：{},共处理:{}个数据，处理完成......", threadName, data.size());
            resultBean.setData(resultList);
        }
        return resultBean;
    }
}

第四步： MultiThreadUtils类，多线程工具类

package com.HM.eis.commons.multiThread;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 
 * @ClassName: MultiThreadUtils.java
 * @Description: 多线程工具类
 */
@SuppressWarnings({ "all" })
public class MultiThreadUtils<T> {	
    private static Logger logger = LoggerFactory.getLogger(MultiThreadUtils.class);
    // 线程个数，如不赋值，默认为5
    private int threadCount = 5;
    // 具体业务任务
    private ITask<ResultBean<String>, T> task;
    // 线程池管理器
    private CompletionService<ResultBean> pool = null;
    /**
     * 初始化线程池和线程个数<BR>
     */
    public static MultiThreadUtils newInstance(int threadCount) {
        MultiThreadUtils instance = new MultiThreadUtils();
        threadCount = threadCount;
        instance.setThreadCount(threadCount);
        return instance;
    }
    /**
     * 
     * 多线程分批执行list中的任务<BR>
     * 方法名：execute<BR>
     */
    public ResultBean execute(List<T> data, Map<String, Object> params, ITask<ResultBean<Object>, T> task) {
        // 创建线程池
        ExecutorService threadpool = Executors.newFixedThreadPool(threadCount);
        // 根据线程池初始化线程池管理器
        pool = new ExecutorCompletionService<ResultBean>(threadpool);
        // 开始时间（ms）
        long l = System.currentTimeMillis();
        // 数据量大小
        int length = data.size();
        // 每个线程处理的数据个数
        int taskCount = length / threadCount;
        // 划分每个线程调用的数据
        for (int i = 0; i < threadCount; i++) {
            // 每个线程任务数据list
            List<T> subData = null;
            if (i == (threadCount - 1)) {
                subData = data.subList(i * taskCount, length);
            } else {
                subData = data.subList(i * taskCount, (i + 1) * taskCount);
            }
            // 将数据分配给各个线程
            HandleCallable execute = new HandleCallable<T>(String.valueOf(i), subData, params, task);
            // 将线程加入到线程池
            pool.submit(execute);
        }        
        // 总的返回结果集
        List<ResultBean<String>> result = new ArrayList<>();
        for (int i = 0; i < threadCount; i++) {
            // 每个线程处理结果集
            ResultBean<List<ResultBean<String>>> threadResult;
            try {
                threadResult = pool.take().get();
                result.addAll(threadResult.getData());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        // 关闭线程池
        threadpool.shutdownNow();
        // 执行结束时间
        long end_l = System.currentTimeMillis();
        logger.info("总耗时:{}ms", (end_l - l));
        return ResultBean.newInstance().setData(result);
    }
    public int getThreadCount() {
        return threadCount;
    }
    public void setThreadCount(int threadCount) {
        this.threadCount = threadCount;
    }
}

第五步： 测试

package com.HM.eig.thread;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.HM.eig.commons.multiThread.ITask;
import com.HM.eig.commons.multiThread.MultiThreadUtils;
import com.HM.eig.commons.multiThread.ResultBean;
/**
 * 具体执行业务任务 需要 实现ITask接口  在execute中重写业务逻辑
 */
public class TestTask implements ITask<ResultBean<String>, Integer> {
    @Override
    public ResultBean execute(Integer e, Map<String, Object> params) {
        /**
         * 具体业务逻辑：将list中的元素加上辅助参数中的数据返回
         */
        int addNum = Integer.valueOf(String.valueOf(params.get("addNum")));
        e = e + addNum;
        ResultBean<String> resultBean = ResultBean.newInstance();
        resultBean.setData(e.toString());
        return resultBean;
    }    
    public static void main(String[] args) {
        // 需要多线程处理的大量数据list
        List<Integer> data = new ArrayList<>(10000);
        for(int i = 0; i < 10000; i ++){
            data.add(i + 1);
        }
        // 创建多线程处理任务
        MultiThreadUtils<Integer> threadUtils = MultiThreadUtils.newInstance(5);
        ITask<ResultBean<String>, Integer> task = new TestTask();
        // 辅助参数  加数
        Map<String, Object> params = new HashMap<>();
        params.put("addNum", 4);
        // 执行多线程处理，并返回处理结果
        ResultBean<List<ResultBean<String>>> resultBean = threadUtils.execute(data, params, task);
    }
}

建议以内部类的形式使用：

public class TestTask {
    public static void main(String[] args) {
        // 需要多线程处理的大量数据list
        List<Integer> data = new ArrayList<>(100);
        for(int i = 0; i < 100; i ++){
            data.add(i + 1);
        }
        // 创建多线程处理任务
        MultiThreadUtils<Integer> threadUtils = MultiThreadUtils.newInstance(4);
        // 辅助参数  加数
        Map<String, Object> params = new HashMap<>();
        params.put("addNum", 4);
        // 执行多线程处理，并返回处理结果
        ResultBean<List<ResultBean<Object>>> resultBean = threadUtils.execute(data, params, new  ITask<ResultBean<Object>, Integer>(){
			@Override
			public ResultBean<Object> execute(Integer e, Map<String, Object> params) {
			    /**
		         * 具体业务逻辑：将list中的元素加上辅助参数中的数据返回
		         */
		        int addNum = Integer.valueOf(String.valueOf(params.get("addNum")));
		        e = e + addNum;
		        ResultBean<Object> resultBean = ResultBean.newInstance();
		        resultBean.setData(e.toString());
		        return resultBean;
			}
        });
    }
}

以上就是关于“Java多线程工具类的使用方法”的介绍，如果想了解更多信息，可以关注一下极悦的Java开发工具，里面有更多的丰富在等着大家去学习，希望对大家能够有所帮助。