Java是否有类似Python timeit模块的代码执行计时工具？

嘿，刚好我之前也折腾过类似的需求！Python的timeit用起来确实省心，Java里当然也有对应的方案，不管是手动写原生实现，还是搞成你想要的注解式（比如@Timeit(number=10)这种）都能搞定，下面给你唠唠具体的办法：

1. 原生手动实现（零依赖） #

如果不想引入第三方库，自己写个工具类就能搞定核心的计时逻辑。推荐用System.nanoTime()来计时，它比System.currentTimeMillis()精度更高，更适合微基准测试场景。

示例工具类：

public class TimeitUtils {
    // 接收任务和执行次数，输出平均耗时
    public static void timeit(Runnable task, int number) {
        long totalNanos = 0;
        
        // 循环执行指定次数，累计耗时
        for (int i = 0; i < number; i++) {
            long start = System.nanoTime();
            task.run();
            long end = System.nanoTime();
            totalNanos += end - start;
        }
        
        // 转换为毫秒并计算平均值
        double avgMs = (totalNanos / (double) number) / 1_000_000;
        System.out.printf("任务执行 %d 次，平均耗时: %.4f ms%n", number, avgMs);
    }
}

使用方式也很简单，和Python的lambda写法类似：

@Test
public void foo() {
    TimeitUtils.timeit(() -> service.foo(), 10);
}

2. 注解式实现（贴合你的@Test场景） #

如果想要像你说的那样用@Timeit(number=10)注解来标记测试方法，我们可以结合自定义注解+AOP或者JUnit扩展来实现，这里给你两种常用的方案：

方案A：Spring环境下用AOP实现 #

如果你的项目是Spring项目，用Spring AOP来拦截注解方法是最方便的：

首先定义@Timeit注解：

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Timeit {
    // 默认执行1次，可通过number参数指定次数
    int number() default 1;
}

然后写一个切面类来处理计时逻辑：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class TimeitAspect {
    @Around("@annotation(timeit)")
    public Object measureMethodTime(ProceedingJoinPoint joinPoint, Timeit timeit) throws Throwable {
        int iterations = timeit.number();
        long totalNanos = 0;
        
        // 先执行指定次数，累计耗时
        for (int i = 0; i < iterations; i++) {
            long start = System.nanoTime();
            joinPoint.proceed(); // 执行目标方法
            long end = System.nanoTime();
            totalNanos += end - start;
        }
        
        // 计算并打印结果
        double avgMs = (totalNanos / (double) iterations) / 1_000_000;
        System.out.printf("方法 [%s] 执行 %d 次，平均耗时: %.4f ms%n",
                joinPoint.getSignature().getName(),
                iterations,
                avgMs);
        
        // 返回方法执行结果（这里返回最后一次的执行结果，可根据需求调整）
        return joinPoint.proceed();
    }
}

最后在测试方法上直接加注解就行：

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

public class FooServiceTest {
    @Autowired
    private FooService service;
    
    @Timeit(number = 10)
    @Test
    public void foo() {
        service.foo();
    }
}

方案B：非Spring环境用JUnit 5扩展实现 #

如果不是Spring项目，用JUnit 5的Extension也能实现注解式计时：

先复用上面的@Timeit注解，然后写一个JUnit扩展类：

import org.junit.jupiter.api.extension.*;
import java.lang.reflect.Method;

public class TimeitExtension implements BeforeTestExecutionCallback, AfterTestExecutionCallback {
    private long startTime;
    private int iterations;

    @Override
    public void beforeTestExecution(ExtensionContext context) throws Exception {
        Method testMethod = context.getRequiredTestMethod();
        Timeit timeit = testMethod.getAnnotation(Timeit.class);
        
        if (timeit != null) {
            iterations = timeit.number();
            startTime = System.nanoTime();
            
            // 先执行iterations-1次（因为JUnit会自动执行一次测试方法）
            for (int i = 0; i < iterations - 1; i++) {
                testMethod.invoke(context.getRequiredTestInstance());
            }
        }
    }

    @Override
    public void afterTestExecution(ExtensionContext context) throws Exception {
        Method testMethod = context.getRequiredTestMethod();
        Timeit timeit = testMethod.getAnnotation(Timeit.class);
        
        if (timeit != null) {
            long endTime = System.nanoTime();
            long totalNanos = endTime - startTime;
            double avgMs = (totalNanos / (double) iterations) / 1_000_000;
            
            System.out.printf("方法 [%s] 执行 %d 次，平均耗时: %.4f ms%n",
                    testMethod.getName(),
                    iterations,
                    avgMs);
        }
    }
}

然后在测试类上注册这个扩展：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(TimeitExtension.class)
public class FooServiceTest {
    private FooService service = new FooService();
    
    @Timeit(number = 10)
    @Test
    public void foo() {
        service.foo();
    }
}

3. 第三方工具库辅助 #

除了自己实现，也有一些成熟的工具库可以简化计时：

• Google Guava：Stopwatch类可以方便地记录耗时，结合循环就能实现类似timeit的功能
• Apache Commons Lang：StopWatch类和Guava的Stopwatch用法类似，也能快速实现计时

不过如果要注解式的体验，还是自己自定义注解+AOP/JUnit扩展更贴合你的需求。

内容的提问来源于stack exchange，提问作者zhuguowei