个人中心
gpt4 book ai didi

JMH–Java基准测试

转载 作者：我是一只小鸟 更新时间：2023-07-03 22:31:47 26 4
gpt4 key购买 nike

官方资源

官方Github样例 。

应用场景

  • 对要使用的数据结构不确定，不知道谁的性能更好
  • 对历史方法代码重构，要评判改造之后的性能提升多少 ( 我要做的场景 ）
  • 想准确地知道某个方法需要执行多长时间，以及执行时间和输入之间的相关性
  • 对比接口不同实现在给定条件下的吞吐量
  • 查看多少百分比的请求在多长时间内完成

背景限制（防杠指南）

  • 业务场景？
    因为当前项目是接手比较老的项目，已经有成熟业务在跑，原先的生成模型是 nextByCalendarAndRandom ， 序号生成是采用两位随机数，然后随机数产生了冲突，一毫秒内产生的两个随机数有冲突，
  • 为什么不直接使用 snowflake?
    原先的生成逻辑 6(商户号) + 15(yyMMddHHmmssSSS 最大长度,可能比15小) + 2(随机数) = 23 （最大长度）
    如果使用雪花算法，则 6 + 19 = 25 （最大长度），且现在业务方较多，不确定对方是否有限制该字段长度，再就是如果对雪花算法进行裁剪，也不能保证肯定不会出现冲突，经衡量过后，暂时不使用雪花算法，后续业务方能确定长度没有问题，就可以升级
  • 这个算法不是分布式的，如果是两台服务器，则出现冲突的可能性就变大了
    是的，如果两台服务同时运行，然后又同时有请求进来，就有很大的可能性出现冲突，但现在的业务状况是单体架构，只不过做了主备服务，主服务宕机，备份才会启动，暂时不会两台服务同时启动
  • 那如果采用 nextByCalendarAndAtomicInteger 自增，就表示一毫秒最大只有100个请求能进来？超过就肯定会冲突？
    是的，这个也是业务决定的，如果我们当前的业务量超过每毫秒超100，那问题可能不是我这里的冲突了，服务会率先被压垮
  • 最终的业务采用什么方法？
    使用了 nextByLocalDateTimeAndAtomicInteger 方法，也有每毫秒超100必定重复的限制

引用依赖 

                        
                                  <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>1.35</version>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>1.35</version>
        </dependency>

测试代码 

                        
                          @UtilityClass
public class IdWork {

    @Deprecated
    public static String nextByCalendarAndRandom(String merchantNo) {

        Calendar now = Calendar.getInstance();
        long random1 = Math.round(Math.random() * 9);
        long random2 = Math.round(Math.random() * 9);
        String timestamp = (now.get(Calendar.YEAR) + "").substring(2)
                + (now.get(Calendar.MONTH) + 1)
                + now.get(Calendar.DAY_OF_MONTH)
                + now.get(Calendar.HOUR_OF_DAY)
                + now.get(Calendar.MINUTE)
                + now.get(Calendar.SECOND)
                + now.get(Calendar.MILLISECOND);
        return merchantNo + timestamp + random1 + random2;
    }

    @Deprecated
    public static String nextByLocalDateTimeAndRandom(String merchantNo) {

        LocalDateTime now = LocalDateTime.now();
        long random1 = Math.round(Math.random() * 9);
        long random2 = Math.round(Math.random() * 9);
        String timestamp = (now.getYear() + "").substring(2)
                + now.getMonthValue()
                + now.getDayOfMonth()
                + now.getHour()
                + now.getMinute()
                + now.getSecond()
                + (now.getNano() / 1000000);
        return merchantNo + timestamp + random1 + random2;
    }

    @Deprecated
    public static String nextByCalendarAndAtomicInteger(String merchantNo) {

        Calendar now = Calendar.getInstance();
        String timestamp = (now.get(Calendar.YEAR) + "").substring(2)
                + (now.get(Calendar.MONTH) + 1)
                + now.get(Calendar.DAY_OF_MONTH)
                + now.get(Calendar.HOUR_OF_DAY)
                + now.get(Calendar.MINUTE)
                + now.get(Calendar.SECOND)
                + now.get(Calendar.MILLISECOND);
        return merchantNo + timestamp + getSeqNo();
    }

    @Deprecated
    public static String nextByLocalDateTimeAndAtomicInteger(String merchantNo) {

        LocalDateTime now = LocalDateTime.now();
        String timestamp = (now.getYear() + "").substring(2)
                + now.getMonthValue()
                + now.getDayOfMonth()
                + now.getHour()
                + now.getMinute()
                + now.getSecond()
                + (now.getNano() / 1000000);
        return merchantNo + timestamp + getSeqNo();
    }

    public static String nextBySnowflake(String merchantNo) {
        return merchantNo + IdGenerator.next();
    }

    private static AtomicInteger seqNo = new AtomicInteger(1);

    private static String getSeqNo() {

        int curSeqNo = seqNo.getAndIncrement();
        if (curSeqNo > 99) { // 重置,也可以取模
            seqNo = new AtomicInteger(1);
        }
        if (curSeqNo < 10) {
            return "0" + curSeqNo;
        }
        return curSeqNo + "";

    }

    public static void main(String[] args) {
        String next1 = IdWork.nextByCalendarAndRandom("900087");
        System.out.println(next1);
        String next2 = IdWork.nextByLocalDateTimeAndRandom("900087");
        System.out.println(next2);
        String next3 = IdWork.nextByCalendarAndAtomicInteger("900087");
        System.out.println(next3);
        String next4 = IdWork.nextByLocalDateTimeAndAtomicInteger("900087");
        System.out.println(next4);
        String next5 = IdWork.nextBySnowflake("900087");
        System.out.println(next5);
    }
}

                        
                      
                        
                          public class IdTest {


    @Benchmark
    public String getIdBySnowflake() {
        return IdWork.nextBySnowflake("900087");
    }

    @Benchmark
    public String nextByCalendarAndRandom() {
        return IdWork.nextByCalendarAndRandom("900087");
    }

    @Benchmark
    public String nextByLocalDateTimeAndRandom() {
        return IdWork.nextByLocalDateTimeAndRandom("900087");
    }

    @Benchmark
    public String nextByCalendarAndAtomicInteger() {
        return IdWork.nextByCalendarAndAtomicInteger("900087");
    }

    @Benchmark
    public String nextByLocalDateTimeAndAtomicInteger() {
        return IdWork.nextByLocalDateTimeAndAtomicInteger("900087");
    }


    public static void main(String[] args) throws RunnerException {

        // 吞吐量
//        Options opt = new OptionsBuilder()
//                .include(IdTest.class.getSimpleName())
//                .mode(Mode.Throughput)
//                .forks(1)
//                .build();

        // 平均耗时
        Options opt = new OptionsBuilder()
                .include(IdTest.class.getSimpleName())
                .mode(Mode.AverageTime)
                .timeUnit(TimeUnit.NANOSECONDS)
                .forks(1)
                .build();

        new Runner(opt).run();

    }

// 吞吐量
//    Benchmark                                    Mode  Cnt        Score        Error  Units
//    IdTest.getIdBySnowflake                     thrpt    5  4070403.840 ±  11302.832  ops/s
//    IdTest.nextByCalendarAndAtomicInteger       thrpt    5  4201822.821 ± 177869.095  ops/s
//    IdTest.nextByCalendarAndRandom              thrpt    5  4085723.001 ±  47505.309  ops/s
//    IdTest.nextByLocalDateTimeAndAtomicInteger  thrpt    5  5036852.390 ± 153313.836  ops/s
//    IdTest.nextByLocalDateTimeAndRandom         thrpt    5  5199148.189 ± 405132.888  ops/s

// 平均耗时
//    Benchmark                                   Mode  Cnt    Score   Error  Units
//    IdTest.getIdBySnowflake                     avgt    5  245.739 ± 0.302  ns/op
//    IdTest.nextByCalendarAndAtomicInteger       avgt    5  239.174 ± 4.244  ns/op
//    IdTest.nextByCalendarAndRandom              avgt    5  251.084 ± 5.798  ns/op
//    IdTest.nextByLocalDateTimeAndAtomicInteger  avgt    5  197.332 ± 0.779  ns/op
//    IdTest.nextByLocalDateTimeAndRandom         avgt    5  212.105 ± 1.888  ns/op

}

概念理解

常用注解

类型 作用域 描述 备注
Benchmark ElementType.METHOD 最重要的注解，标记需要执行的方法
BenchmarkMode ElementType.METHOD, ElementType.TYPE 统计的维度，有吞吐量，平均耗时，也可以组合使用
Fork ElementType.METHOD, ElementType.TYPE 复制多个进程来执行方法，每轮默认Iteration循环5次，如果fork 3，则会执行3*5 次，一般默认值1就可以
Measurement ElementType.METHOD, ElementType.TYPE 方法控制：循环次数，每次循环时间以及对应的时间单位
Warmup ElementType.METHOD,ElementType.TYPE 预热，避免系统冷启动导致的性能测试不准
OutputTimeUnit ElementType.METHOD, ElementType.TYPE 输出时间单位，默认是秒
Param ElementType.FIELD 可以指定遍历参数，针对特殊字段测试不同的性能
Setup ElementType.METHOD 启动类设置，类似 junit Before类型注解
TearDown ElementType.METHOD 销毁类设置，类似junit After类型注解，一般用于销毁池化的资源
Threads ElementType.METHOD,ElementType.TYPE
Timeout ElementType.METHOD,ElementType.TYPE
AuxCounters ElementType.TYPE 辅助计数器，可以统计 @State 修饰的对象中的 public 属性被执行的情况
Group ElementType.METHOD
GroupThreads ElementType.METHOD
CompilerControl ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.TYPE 内联扩展是一种特别的用于消除调用函数时所造成的固有时间消耗方法，这里用来控制方法或类是否内联
OperationsPerInvocation ElementType.METHOD, ElementType.TYPE

BenchmarkMode 执行模式（可以多个组合执行） 。

类型 描述
Throughput 每段时间执行的次数，一般是秒
AverageTime 平均时间，每次操作的平均耗时
SampleTime 在测试中，随机进行采样执行的时间
SingleShotTime 在每次执行中计算耗时
All 所有模式 
                        
                          // 常用的注解
@BenchmarkMode({Mode.Throughput,Mode.AverageTime})
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class BenchmarkTest {
    @Benchmark
    public long test() {}
}

// 使用 OptionsBuilder 建造者模式构建 Options, 然后在main方法执行,建议使用
Options opt = new OptionsBuilder()
        .include(IdTest.class.getSimpleName())
        .mode(Mode.AverageTime)
        .mode(Mode.Throughput)
        .timeUnit(TimeUnit.NANOSECONDS)
        .warmupIterations(3)
        .warmupTime(TimeValue.seconds(1))
        .measurementIterations(5)
        .measurementTime(TimeValue.seconds(1))
        .forks(1)
        .build();

一些提示

避免循环 。

JVM会对循环进行优化，这样会导致获取的测试结果不准确.

引用资源

jmh-java-microbenchmark-harness jenkov: java-performance jmh-benchmark-with-examples Java基准测试工具 —— JMH使用指南 。

最后此篇关于JMH–Java基准测试的文章就讲到这里了,如果你想了解更多关于JMH–Java基准测试的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： 【序列化与反序列化】关于序列化与反序列化MessagePack的实践
文章推荐： DevOps｜从腾讯TEGCDC解散聊技术中台价值和建设
文章推荐： SpringBoot项目从0到1配置logback日志打印
文章推荐： Pythonweb框架对比：FlaskvsDjango
我是一只小鸟
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com