<properties>    <jmh.version>1.14.1</jmh.version></properties>
<dependencies>    <dependency>        <groupId>org.openjdk.jmh</groupId>        <artifactId>jmh-core</artifactId>        <version>${jmh.version}</version>    </dependency>    <dependency>        <groupId>org.openjdk.jmh</groupId>        <artifactId>jmh-generator-annprocess</artifactId>        <version>${jmh.version}</version>        <scope>provided</scope>    </dependency></dependencies>

package com.ckj.base.designPatternes.proxy.DynamicProxy;
import org.openjdk.jmh.annotations.*;import org.springframework.cglib.proxy.Enhancer;import org.springframework.cglib.proxy.MethodInterceptor;import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;import java.util.concurrent.TimeUnit;
/** * @author c.kj * @Description * @Date 2021-03-04 * @Time 21:55 **/@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)@State(Scope.Thread)@Fork(1)public class CglibProxy {
    @Benchmark    @Warmup(iterations = 5, time = 100, timeUnit = TimeUnit.MICROSECONDS)    @Measurement(iterations = 5, time = 100, timeUnit = TimeUnit.MICROSECONDS)    public int measureName() throws InterruptedException {       Thread.sleep(1);        getProxyInstance();        return 0;    }
    public Object getProxyInstance() {        Enhancer enhancer = new Enhancer();        enhancer.setSuperclass(CglibTarget.class);        MethodInterceptor methodInterceptor = new MethodInterceptor() {            @Override            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)                    throws Throwable {
                System.out.println("intercept start....");                Object o1 = methodProxy.invokeSuper(o, objects);                System.out.println("intercept end....");
                return o1;            }        };        enhancer.setCallback(methodInterceptor);        Object o = enhancer.create();        return o;
    }
}

# JMH 1.14.1 (released 1780 days ago, please consider updating!)# VM version: JDK 1.8.0_201, VM 25.201-b09# VM invoker: /Library/Java/JavaVirtualmachines/jdk1.8.0_201.jdk/Contents/Home/jre/bin/java# VM options: -Dvisualvm.id=94033462347806 -javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=56278:/Applications/IntelliJ IDEA.app/Contents/bin -Dfile.encoding=UTF-8# Warmup: 5 iterations, 100 us each# Measurement: 5 iterations, 100 us each# Timeout: 10 min per iteration# Threads: 1 thread, will synchronize iterations# Benchmark mode: Average time, time/op# Benchmark: com.ckj.base.designPatternes.proxy.DynamicProxy.CglibProxy.measureName
# Run progress: 0.00% complete, ETA 00:00:00# Fork: 1 of 1# Warmup Iteration   1: 68584.809 us/op# Warmup Iteration   2: 1312.436 us/op# Warmup Iteration   3: 1329.796 us/op# Warmup Iteration   4: 1329.558 us/op# Warmup Iteration   5: 1296.309 us/opIteration   1: 1296.129 us/opIteration   2: 1121.620 us/opIteration   3: 1603.035 us/opIteration   4: 1306.412 us/opIteration   5: 1194.444 us/op

Result "measureName":  1304.328 ±(99.9%) 706.764 us/op [Average]  (min, avg, max) = (1121.620, 1304.328, 1603.035), stdev = 183.544  CI (99.9%): [597.564, 2011.092] (assumes normal distribution)

# Run complete. Total time: 00:00:01
Benchmark                                                  Mode  Cnt     Score     Error  UnitsdesignPatternes.proxy.DynamicProxy.CglibProxy.measureName  avgt    5  1304.328 ± 706.764  us/op
Process finished with exit code 0

Options opt = new OptionsBuilder()        .include(FirstBenchmark.class.getSimpleName())        .forks(1)        .warmupIterations(5)        .measurementIterations(5)        .build();
new Runner(opt).run();

public interface Calculator {    /**     * calculate sum of an integer array     * @param numbers     * @return     */    public long sum(int[] numbers);
    /**     * shutdown pool or reclAIm any related resources     */    public void shutdown();}

@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)@State(Scope.Benchmark)public class SecondBenchmark {    @Param({"10000", "100000", "1000000"})    private int length;
    private int[] numbers;    private Calculator singleThreadCalc;    private Calculator multiThreadCalc;
    public static void main(String[] args) throws RunnerException {        Options opt = new OptionsBuilder()                .include(SecondBenchmark.class.getSimpleName())                .forks(2)                .warmupIterations(5)                .measurementIterations(5)                .build();
        new Runner(opt).run();    }
    @Benchmark    public long singleThreadBench() {        return singleThreadCalc.sum(numbers);    }
    @Benchmark    public long multiThreadBench() {        return multiThreadCalc.sum(numbers);    }
    @Setup    public void prepare() {        numbers = IntStream.rangeClosed(1, length).toArray();        singleThreadCalc = new SinglethreadCalculator();        multiThreadCalc = new MultithreadCalculator(Runtime.getRuntime().availableProcessors());    }
    @TearDown    public void shutdown() {        singleThreadCalc.shutdown();        multiThreadCalc.shutdown();    }}

public class SinglethreadCalculator implements Calculator {    public long sum(int[] numbers) {        long total = 0L;        for (int i : numbers) {            total += i;        }        return total;    }
    @Override    public void shutdown() {        // nothing to do    }}
public class MultithreadCalculator implements Calculator {    private final int nThreads;    private final ExecutorService pool;
    public MultithreadCalculator(int nThreads) {        this.nThreads = nThreads;        this.pool = Executors.newFixedThreadPool(nThreads);    }
    private class SumTask implements Callable<Long> {        private int[] numbers;        private int from;        private int to;
        public SumTask(int[] numbers, int from, int to) {            this.numbers = numbers;            this.from = from;            this.to = to;        }
        public Long call() throws Exception {            long total = 0L;            for (int i = from; i < to; i++) {                total += numbers[i];            }            return total;        }    }
    public long sum(int[] numbers) {        int chunk = numbers.length / nThreads;
        int from, to;        List<SumTask> tasks = new ArrayList<SumTask>();        for (int i = 1; i <= nThreads; i++) {            if (i == nThreads) {                from = (i - 1) * chunk;                to = numbers.length;            } else {                from = (i - 1) * chunk;                to = i * chunk;            }            tasks.add(new SumTask(numbers, from, to));        }
        try {            List<Future<Long>> futures = pool.invokeAll(tasks);
            long total = 0L;            for (Future<Long> future : futures) {                total += future.get();            }            return total;        } catch (Exception e) {            // ignore            return 0;        }    }
    @Override    public void shutdown() {        pool.shutdown();    }}