在Java开发中，任务完成统计是很多业务场景的必备需求，比如批量处理用户数据、异步执行多个接口调用、多线程拆分大任务执行等场景，都需要准确统计任务的完成状态、数量以及执行结果。下文将介绍几种常用的实现方案，你可以根据业务场景选择合适的实现方式。
基础场景：单线程下的任务统计
如果是单线程执行任务，统计逻辑非常简单，只需要定义一个计数器，每完成一个任务就递增计数即可。
public class SingleThreadTaskStat {
// 已完成任务计数器
private int completedCount = 0;
// 总任务数
private final int totalTaskCount;
public SingleThreadTaskStat(int totalTaskCount) {
this.totalTaskCount = totalTaskCount;
}
// 执行单个任务
public void executeTask() {
// 模拟任务执行逻辑
System.out.println("任务执行完成");
completedCount++;
}
// 获取完成进度
public double getCompleteProgress() {
return (double) completedCount / totalTaskCount * 100;
}
public static void main(String[] args) {
SingleThreadTaskStat stat = new SingleThreadTaskStat(10);
for (int i = 0; i < 10; i++) {
stat.executeTask();
}
System.out.println("任务完成进度：" + stat.getCompleteProgress() + "%");
}
}多线程场景：使用原子类实现线程安全统计
多线程场景下，普通的int计数器会出现竞态条件，导致统计结果不准确，此时可以使用java.util.concurrent.atomic包下的原子类，比如AtomicInteger来实现线程安全的计数。
import java.util.concurrent.atomic.AtomicInteger;
public class MultiThreadAtomicStat {
// 原子计数器，线程安全
private final AtomicInteger completedCount = new AtomicInteger(0);
// 失败任务计数器
private final AtomicInteger failedCount = new AtomicInteger(0);
private final int totalTaskCount;
public MultiThreadAtomicStat(int totalTaskCount) {
this.totalTaskCount = totalTaskCount;
}
// 执行任务，模拟可能的成功或失败
public void executeTask(boolean isSuccess) {
if (isSuccess) {
completedCount.incrementAndGet();
} else {
failedCount.incrementAndGet();
}
}
// 获取成功率
public double getSuccessRate() {
int totalFinished = completedCount.get() + failedCount.get();
if (totalFinished == 0) {
return 0.0;
}
return (double) completedCount.get() / totalFinished * 100;
}
public static void main(String[] args) throws InterruptedException {
MultiThreadAtomicStat stat = new MultiThreadAtomicStat(20);
// 模拟10个线程执行任务
for (int i = 0; i < 10; i++) {
final int taskId = i;
new Thread(() -> {
// 模拟任务执行，随机成功或失败
boolean success = taskId % 3 != 0;
stat.executeTask(success);
System.out.println("任务" + taskId + "执行完成，状态：" + (success ? "成功" : "失败"));
}).start();
}
// 等待所有线程执行完成
Thread.sleep(1000);
System.out.println("已完成任务数：" + stat.completedCount.get());
System.out.println("失败任务数：" + stat.failedCount.get());
System.out.println("任务成功率：" + stat.getSuccessRate() + "%");
}
}线程池场景：利用线程池内置统计能力
如果使用线程池执行任务，不需要自己额外维护计数器，线程池的ThreadPoolExecutor类已经内置了任务统计相关的方法，可以直接获取已完成任务数、总提交任务数等信息。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolStatDemo {
public static void main(String[] args) throws InterruptedException {
// 创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, // 空闲线程存活时间
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(10) // 任务队列
);
// 提交10个任务
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("任务" + taskId + "开始执行");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("任务" + taskId + "执行完成");
});
}
// 等待所有任务执行完成
executor.shutdown();
while (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
// 每秒打印一次统计信息
System.out.println("已提交任务数：" + executor.getTaskCount());
System.out.println("已完成任务数：" + executor.getCompletedTaskCount());
System.out.println("当前活跃线程数：" + executor.getActiveCount());
}
// 最终统计
System.out.println("最终已提交任务数：" + executor.getTaskCount());
System.out.println("最终已完成任务数：" + executor.getCompletedTaskCount());
}
}复杂场景：自定义统计组件
如果业务需要统计更多维度的信息，比如任务耗时、按任务类型分类统计等，可以自定义统计组件，结合原子类和线程安全的集合实现多维度统计。
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
public class CustomTaskStat {
// 总已完成任务数
private final AtomicInteger totalCompleted = new AtomicInteger(0);
// 按任务类型统计的完成数
private final ConcurrentHashMap<String, AtomicInteger> typeCompletedMap = new ConcurrentHashMap<>();
// 总任务耗时（纳秒）
private final AtomicLong totalCostTime = new AtomicLong(0);
// 记录任务完成，传入任务类型和耗时
public void recordTaskComplete(String taskType, long costTimeNs) {
totalCompleted.incrementAndGet();
totalCostTime.addAndGet(costTimeNs);
// 按类型累加计数，computeIfAbsent保证线程安全
typeCompletedMap.computeIfAbsent(taskType, k -> new AtomicInteger(0)).incrementAndGet();
}
// 获取总完成数
public int getTotalCompleted() {
return totalCompleted.get();
}
// 获取平均任务耗时（毫秒）
public double getAvgCostTimeMs() {
int completed = totalCompleted.get();
if (completed == 0) {
return 0.0;
}
return totalCostTime.get() / (double) completed / 1000000;
}
// 获取指定类型的完成数
public int getTypeCompleted(String taskType) {
AtomicInteger count = typeCompletedMap.get(taskType);
return count == null ? 0 : count.get();
}
public static void main(String[] args) {
CustomTaskStat stat = new CustomTaskStat();
// 模拟不同类型任务完成
stat.recordTaskComplete("数据同步", 200000000); // 200毫秒
stat.recordTaskComplete("数据同步", 300000000); // 300毫秒
stat.recordTaskComplete("接口调用", 150000000); // 150毫秒
System.out.println("总完成任务数：" + stat.getTotalCompleted());
System.out.println("平均任务耗时：" + stat.getAvgCostTimeMs() + "毫秒");
System.out.println("数据同步类型完成数：" + stat.getTypeCompleted("数据同步"));
System.out.println("接口调用类型完成数：" + stat.getTypeCompleted("接口调用"));
}
}注意事项
- 多线程场景下不要使用普通的基本类型变量做计数，避免竞态条件导致统计错误。
- 如果需要统计任务的成功失败状态，建议分别维护成功和失败的计数器，避免后续计算错误。
- 线程池的统计方法
getCompletedTaskCount()返回的是已经执行完成的任务数，不包括还在队列中等待的任务，使用时需要区分清楚。 - 自定义统计组件时，如果涉及多维度统计，优先选择
ConcurrentHashMap等线程安全的集合类，避免并发修改异常。