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;
}
/**
* 实例化结果默认成功状态
* 方法名：newInstance
*/
public static <T> ResultBean<T> newInstance() {
ResultBean<T> instance = new ResultBean<T>();
//默认返回信息
instance.code = SUCCESS;
instance.msg = "success";
return instance;
}
/**
* 实例化结果默认成功状态和数据
* 方法名：newInstance
*/
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;
}
/**
* 实例化返回结果
* 方法名：newInstance
*/
public static <T> ResultBean<T> newInstance(int code, String msg) {
ResultBean<T> instance = new ResultBean<T>();
//默认返回信息
instance.code = code;
instance.msg = msg;
return instance;
}
/**
* 实例化返回结果
* 方法名：newInstance
*/
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;
}
/**
* 设置返回数据
* 方法名：setData
*/
public ResultBean<T> setData(T data){
this.data = data;
return this;
}
/**
* 设置结果描述
* 方法名：setMsg
*/
public ResultBean<T> setMsg(String msg){
this.msg = msg;
return this;
}
/**
* 设置状态
* 方法名：setCode
*/
public ResultBean<T> setCode(int code){
this.code = code;
return this;
}
/**
* 设置备注)
* 方法名：setRemark
*/
public ResultBean<T> setRemark(String remark){
this.remark = remark;
return this;
}
/**
* 设置成功描述和返回数据
* 方法名：success
*/
public ResultBean<T> success(String msg, T data){
this.code = SUCCESS;
this.data = data;
this.msg = msg;
return this;
}
/**
* 设置成功返回结果描述
* 方法名：success
*/
public ResultBean<T> success(String msg){
this.code = SUCCESS;
this.msg = msg;
return this;
}
/**
* 设置处理中描述和返回数据
* 方法名：success
*/
public ResultBean<T> processing(String msg, T data){
this.code = PROCESSING;
this.data = data;
this.msg = msg;
return this;
}
/**
* 设置处理中返回结果描述
* 方法名：success
*/
public ResultBean<T> processing(String msg){
this.code = PROCESSING;
this.msg = msg;
return this;
}
/**
* 设置失败返回描述和返回数据
* 方法名：fail
*/
public ResultBean<T> fail(String msg, T data){
this.code = FAIL;
this.data = data;
this.msg = msg;
return this;
}
/**
* 设置失败返回描述
* 方法名：fail
*/
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字符串
* 方法名：json
*/
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> {
/**
* 任务执行方法接口
* 方法名：execute
* @param e 传入对象
* @param params 其他辅助参数
* @return T
返回值类型
*/
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;
/**
* 初始化线程池和线程个数
*/
public static MultiThreadUtils newInstance(int threadCount) {
MultiThreadUtils instance = new MultiThreadUtils();
threadCount = threadCount;
instance.setThreadCount(threadCount);
return instance;
}
/**
*
* 多线程分批执行list中的任务
* 方法名：execute
*/
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;
}
});
}
}