精华内容
下载资源
问答
  • JMH】在spring boot中使用jmh进行性能测试
    2022-04-04 23:54:01
    更多相关内容
  • https://blog.csdn.net/xiandafu/article/details/94029094 已阅读 https://blog.csdn.net/lxbjkben/article/details/79410740

    https://blog.csdn.net/xiandafu/article/details/94029094 已阅读
    https://blog.csdn.net/lxbjkben/article/details/79410740

    注意:
    这里有个巨坑,就是,这个jar包和lombok+logback日志功能会存在一个莫名其妙的冲突

    解决办法:
    jmh 相关依赖要放到最后面(至少在lombok+logback后面),否则lombok无法正常使用

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.rh</groupId>
        <artifactId>JavaThread</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <name>JavaThread</name>
        <!-- FIXME change it to the project's website -->
        <url>http://www.example.com</url>
    
        <properties>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <jmh.version>1.15</jmh.version>
            <uberjar.name>benchmarks</uberjar.name>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
                <scope>test</scope>
            </dependency>
    
            <dependency>
                <groupId>com.lmax</groupId>
                <artifactId>disruptor</artifactId>
                <version>3.3.2</version>
            </dependency>
    
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.10.0</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
    <!--            <version>1.16.18</version>-->
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>1.2.3</version>
            </dependency>
    
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
    
            <!-- jmh 相关依赖要放到最后面,否则lombok无法正常使用 -->
            <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>
            <!-- jmh 相关依赖要放到最后面,否则lombok无法正常使用 -->
    
        </dependencies>
    
        <build>
            <finalName>Java-Thred</finalName><!-- 导出jar的名字 -->
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>3.2.0</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <transformers>
                                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        <mainClass>com.rh.vedio.Sync</mainClass>
                                        <!-- 主类的位置,例如上图文件,主类配置应为: -->
                                        <!-- <mainClass>top.nihilwater.App</mainClass> -->
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </project>
    
    
    展开全文
  • jmh-core-1.23.jar

    2020-08-05 15:37:40
    OnJava8书中示例必须的jmh包。书中示例程序import了此包的类,如果没有此文件,OnJava8书中示例将无法在idea中顺利运行
  • 要想使用JMH,首先需要得到JMH的jar,一种简单可行的方式是使用Maven进行导入,代码如下: 其中被度量的代码为函数MainApp()。类似于JUnit,被度量代码用注解@Benchmark标注,这里仅仅为一个空函数。在main()...
  • JMH即Java Microbenchmark Harness,@Benchmark的使用用来压测dubbo很方便,比较了jmeter、ab、jmh,还是jmh好用

    1、JMH简介

    JMHJava Microbenchmark Harness,是Java用来做基准测试的一个工具,该工具由OpenJDK提供并维护,测试结果可信度高。

    相对于 Jmeter、ab ,它通过编写代码的方式进行压测,在特定场景下会更能评估某项性能。

    本次通过使用JMH来压测Dubbo的性能(官方也是使用JMH压测)

    2、使用

    只需要引用两个jar即可:

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

    通过一系列的注解即可使用JMH。

    @State

    只能用在类上,有三个取值:

    Scope.Thread:默认的State,每个测试线程分配一个实例;
    Scope.Benchmark:所有测试线程共享一个实例,用于测试有状态实例在多线程共享下的性能;
    Scope.Group:每个线程组共享一个实例;

    @OutputTimeUnit

    时间单位,如毫秒 TimeUnit.MILLISECONDS、秒 TimeUnit.SECONDS

    @Benchmark

    声明一个public方法为基准测试方法。该类下的所有被@Benchmark注解的方法都会执行。

    相当于类的main方法

    @BenchmarkMode

    指定测试某个接口的指标,如吞吐量、平均执行时间,一般我都是选择 ALL

    Mode有:

    • Throughput: 整体吞吐量,例如“1秒内可以执行多少次调用” (thrpt,参加第5点)

    • AverageTime: 调用的平均时间,例如“每次调用平均耗时xxx毫秒”。(avgt)

    • SampleTime: 随机取样,最后输出取样结果的分布,例如“99%的调用在xxx毫秒以内,99.99%的调用在xxx毫秒以内”(simple)

    • SingleShotTime: 以上模式都是默认一次 iteration 是 1s,唯有 SingleShotTime 是只运行一次。往往同时把 warmup 次数设为0,用于测试冷启动时的性能。(ss)

    @BenchmarkMode({Mode.Throughput,Mode.All})
    public class StressTestProvider {
    
    }
    

    @Measurement

    用于控制压测的次数

    //测量2次,每次测量的持续时间为20秒
    @Measurement(iterations = 2, time = 20 , timeUnit = TimeUnit.SECONDS)
    

    @Warmup

    预热,预热可以避免首次因为一些其他因素,如CPU波动、类加载耗时这些情况的影响。

    @Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
    

    参数解释同上。

    @Fork

    @Fork用于指定fork出多少个子进程来执行同一基准测试方法。

    @Threads

    @Threads注解用于指定使用多少个线程来执行基准测试方法,如果使用@Threads指定线程数为2,那么每次测量都会创建两个线程来执行基准测试方法。

    3、运行

    我这里的例子是压测dubbo,源码链接在文末

    完整例子:

    @BenchmarkMode({Mode.All})
    @Warmup(iterations = 3, time = 5, timeUnit = TimeUnit.SECONDS)
    //测量次数,每次测量的持续时间
    @Measurement(iterations = 3, time = 10, timeUnit = TimeUnit.SECONDS)
    @Threads(32)
    @Fork(1)
    @State(Scope.Benchmark)
    @OutputTimeUnit(TimeUnit.SECONDS)
    @Slf4j
    public class StressTestProvider {
    
        private final AnnotationConfigApplicationContext annotationConfigApplicationContext;
        private final StressTestController stressTestController;
    
        public StressTestProvider() {
            annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AnnotationConfig.class);
            annotationConfigApplicationContext.start();
            stressTestController = annotationConfigApplicationContext.getBean("stressTestController", StressTestController.class);
        }
    
    
        @TearDown
        public void close() throws IOException {
            annotationConfigApplicationContext.close();
        }
    
        @Benchmark
        public void string1k() {
            stressTestController.string1k();
        }
    
        @Benchmark
        public void string100k() {
            stressTestController.string100k();
        }
    
        public static void main(String[] args) throws RunnerException {
    
            log.info("测试开始");
            Options opt = new OptionsBuilder()
                    .include(StressTestProvider.class.getSimpleName())
                //可以通过注解注入
    //                .warmupIterations(3)
    //                .warmupTime(TimeValue.seconds(10))
                //报告输出
                    .result("result.json")
                //报告格式
                    .resultFormat(ResultFormatType.JSON).build();
            new Runner(opt).run();
        }
    }
    

    有两种运行的方式,一般采用打成jar这种。

    3.1、main方法运行

    如上,只需要 配置Options,运行main方法即可,注意要使用 run模式启动,不要使用debug模式启动。

    否则会报错:

    transport error 202: connect failed: Connection refused ERROR
    

    3.2、打成jar运行

    有时候需要放在服务器上运行,就需要打成一个jar,需要使用单独的jar打包插件:

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>jmh-demo</finalName>
                            <transformers>
                                <transformer
                                             implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>org.openjdk.jmh.Main</mainClass>
                                </transformer>
                                <transformer
                                             implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    

    如果不想要这种打包方式,打成jar的时候一定要声明main方法入口对应的类,也就是上面StressTestProvider

    还有就是,因为我的是springboot项目,我测试了一下想同时打包springboot和 jmh:

    但是运行 jhm-demo.jar 发现报错:not match main class,还是老老实实通过 profile 节点打包吧。

    打完包后,通过以下命令即可运行:

    java -jar jmh-demo.jar  -rf json -rff result.json
    

    -rf json 是输出 json的格式

    -rff /data/result.json 是输出文件位置和名称

    4、结果

    执行后,会生成一个汇总结果:

    Result "com.dubbo.benchmark.StressTestProvider.string1k":
      N = 3
      mean =      0.016 ±(99.9%) 0.022 s/op
    
      Histogram, s/op:
        [0.014, 0.014) = 0 
        [0.014, 0.015) = 0 
        [0.015, 0.015) = 0 
        [0.015, 0.015) = 1 
        [0.015, 0.015) = 1 
        [0.015, 0.016) = 0 
        [0.016, 0.016) = 0 
        [0.016, 0.016) = 0 
        [0.016, 0.016) = 0 
        [0.016, 0.017) = 0 
        [0.017, 0.017) = 0 
        [0.017, 0.017) = 0 
        [0.017, 0.017) = 1 
        [0.017, 0.018) = 0 
        [0.018, 0.018) = 0 
        [0.018, 0.018) = 0 
    
      Percentiles, s/op:
          p(0.0000) =      0.015 s/op
         p(50.0000) =      0.015 s/op
         p(90.0000) =      0.017 s/op
         p(95.0000) =      0.017 s/op
         p(99.0000) =      0.017 s/op
         p(99.9000) =      0.017 s/op
         p(99.9900) =      0.017 s/op
         p(99.9990) =      0.017 s/op
         p(99.9999) =      0.017 s/op
        p(100.0000) =      0.017 s/op
    
    # 第36行
    # Run complete. Total time: 00:05:12
    
    Benchmark                                           Mode     Cnt     Score      Error  Units
    StressTestProvider.string100k                      thrpt       3   759.794 ±   66.300  ops/s
    StressTestProvider.string1k                        thrpt       3  6798.005 ± 6992.093  ops/s
    StressTestProvider.string100k                       avgt       3     0.042 ±    0.002   s/op
    StressTestProvider.string1k                         avgt       3     0.005 ±    0.012   s/op
    StressTestProvider.string100k                     sample   22982     0.042 ±    0.001   s/op
    StressTestProvider.string100k:string100k·p0.00    sample             0.017              s/op
    StressTestProvider.string100k:string100k·p0.50    sample             0.041              s/op
    StressTestProvider.string100k:string100k·p0.90    sample             0.048              s/op
    StressTestProvider.string100k:string100k·p0.95    sample             0.050              s/op
    StressTestProvider.string100k:string100k·p0.99    sample             0.058              s/op
    StressTestProvider.string100k:string100k·p0.999   sample             0.075              s/op
    StressTestProvider.string100k:string100k·p0.9999  sample             0.088              s/op
    StressTestProvider.string100k:string100k·p1.00    sample             0.092              s/op
    
    StressTestProvider.string1k                       sample  186906     0.005 ±    0.001   s/op
    StressTestProvider.string1k:string1k·p0.00        sample             0.001              s/op
    StressTestProvider.string1k:string1k·p0.50        sample             0.005              s/op
    StressTestProvider.string1k:string1k·p0.90        sample             0.007              s/op
    StressTestProvider.string1k:string1k·p0.95        sample             0.008              s/op
    StressTestProvider.string1k:string1k·p0.99        sample             0.011              s/op
    StressTestProvider.string1k:string1k·p0.999       sample             0.030              s/op
    StressTestProvider.string1k:string1k·p0.9999      sample             0.035              s/op
    StressTestProvider.string1k:string1k·p1.00        sample             0.038              s/op
    StressTestProvider.string100k                         ss       3     0.030 ±    0.181   s/op
    StressTestProvider.string1k                           ss       3     0.016 ±    0.022   s/op
         
    Benchmark result is saved to result.json
    

    结果分析

    简单分析一下:

    只需要从第36行开始看,我这里一共压测了2个方法

    • StressTestProvider.string100k
    • StressTestProvider.string1k

    Mode

    这一列表示测试的名称,也就是 @BenchmarkMode你选择的测试类型,源码在此:

    public enum Mode {
        /**
         * <p>Throughput: operations per unit of time.</p>
         */
        Throughput("thrpt", "Throughput, ops/time"),
    
        /**
         * <p>Average time: average time per per operation.</p>
         *
         */
        AverageTime("avgt", "Average time, time/op"),
    
        /**
         * <p>Sample time: samples the time for each operation.</p>
         *
         */
        SampleTime("sample", "Sampling time"),
    
        /**
         * <p>Single shot time: measures the time for a single operation.</p>
         *
         */
        SingleShotTime("ss", "Single shot invocation time"),
    
    

    thrpt:吞吐量,也可以理解为tps、ops

    avgt:每次请求的平均耗时

    sample:请求样本数量,这次压测一共发了多少个请求

    ss:除去冷启动,一共执行了多少轮

    Cnt、Score、Units

    单位

    Error

    误差

    如果你配置了输出文件,比如我上面的 resul.json ,但是你打开是看不懂的,可以借助两个网站把文件上传进行分析:

    汇总:

    以上对dubbo进行了分别传输1k和100k的数据压测。

    provider机器:

    2核4g
    
    CentOS release 6.4 (Final)
    model name      : QEMU Virtual CPU version 2.5+
    stepping        : 3
    cpu MHz         : 2099.998
    cache size      : 4096 KB
    

    JVM:

    jdk1.8
    -server -Xmx2g -Xms2g -XX:+UseG1GC 
    

    dubbo:

    版本:2.7.3
    序列化:hessian2
    使用默认dubbo线程数
    

    压测参数:

    32并发

    1k100k
    TPS6700760
    RTT95% 8ms95% 50ms
    AVGTime/OP5ms42ms
    OOM

    对比了 jmeter、Apache-Benmark(ab)、jmh 这三个压测工具,个人比较推荐使用jmh,原因有:

    • jmh压测简单,只需要引入依赖,声明注解
    • 准确性高,目前大多数性能压测都是使用jmh
    • 缺点就是代码入侵

    灵感参考:



    分享一些Java资源:

    Java学习路线思维导图+Java学习视频+简历模板+Java电子书

    展开全文
  • JMH( Java Microbenchmark Harness )是一个用于微测的工具,可以类比成JUNIT,后者用于代码正确性,前者用于代码的性能测试。 开始第一个简单的JMH程序 简单步骤概括: 1.直接打开命令行/console ,通过maven ...

    介绍

    JMH( Java Microbenchmark Harness )是一个用于微测的工具,可以类比成JUNIT,后者用于代码正确性,前者用于代码的性能测试。

    开始第一个简单的JMH程序

    简单步骤概括:

    1.直接打开命令行/console ,通过maven archetype 生成jmh项目

    2.然后在项目中编写需要进行微测的方法(可以指定检测输出,循环几次,以及测试数据

    3.maven clean install 打包,然后运行benchmark.jar

    第一步,生成JMH项目

    //mvn创建命令,此处为了展示方便添加了换行符
    //window执行每行末尾可以加上 ^ ,unix执行每行末尾加上 /
    mvn archetype:generate
              -DinteractiveMode=false
              -DarchetypeGroupId=org.openjdk.jmh
              -DarchetypeArtifactId=jmh-java-benchmark-archetype
    		  -DarchetypeVersion=1.25 
              -DgroupId=com.willl
              -DartifactId=benchmark-test
              -Dversion=1.0
    
    DarchetypeVersion=1.25  //jmh版本
    DgroupId=com.willl   //改成自己的groupId,如果想要整合成项目中的module,此处记得和父项目相同
    DartifactId=benchmark-test //生成的项目名
    

    博主在window cmd中执行:
    生成项目

    //cmd中执行注意空格之类的,linux中^换成/
    mvn archetype:generate ^
    -DinteractiveMode=false ^
    -DarchetypeGroupId=org.openjdk.jmh ^
    -DarchetypeArtifactId=jmh-java-benchmark-archetype ^
    -DarchetypeVersion=1.25 ^
    -DgroupId=com.willl ^
    -DartifactId=benchmark-test ^
    -Dversion=1.0
    

    第二步,在项目中编写自己需要测试的类

    使用maven提供的默认类作为参考编写,先不用纠结注解的具体使用

    package com.willl;
    
    import org.openjdk.jmh.annotations.Benchmark;
    
    @BenchmarkMode(Mode.AverageTime) //标识测试平均时长
    @Warmup(iterations = 2)  //理解成热身
    @Measurement(iterations = 2) //理解成循环几次,然后算平均
    public class MyBenchmark {
    
        @Benchmark //标识需要进行微测
        public void testMethod() {
        	//随意代码
            for(int i = 0;i<100000;i++){
            }
        }
    }
    

    第三步,打包,运行jar包

    mvn clean install
    java -jar benchmark.jar
    

    这是我测试(indexof、regex find 以及match)的结果

    Benchmark               Mode  Cnt    Score   Error  Units
     * Ext_Test.test_indexof   avgt   20    0.218 ± 0.006  ms/op
     * Ext_Test.test_regFind   avgt   20   59.516 ± 2.447  ms/op
     * Ext_Test.test_regMatch  avgt   20  140.552 ± 4.284  ms/op
    

    分析项目结构以及pom文件

    项目结构就是一个simple的maven项目,主要是pom文件

    <!--折叠不必要部分-->
    1.引入2个依赖
    <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>
    
    	<!--变量-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jmh.version>1.25</jmh.version>
        <javac.target>1.8</javac.target>
        <!--生成jar包名-->
        <uberjar.name>benchmarks</uberjar.name>
    </properties>
    
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.2.1</version>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>shade</goal>
                </goals>
                <configuration>
                    <finalName>${uberjar.name}</finalName>
                    <transformers>
                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                            <mainClass>org.openjdk.jmh.Main</mainClass>
                        </transformer>
                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                    </transformers>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
            </execution>
        </executions>
    </plugin>
    
    

    知道pom文件以及相关依赖,我们就可以有别的选择。

    1.那就是将benchmark整合进项目,作为一个module。虽然在很多教程中都指出这样并不是一个很好的主意,但是存在即合理。2.直接将benchmark的代码耦合进主项目。

    第二种想法,直接将上述pom文件拷入就行,这样打包的话就需要将整个项目进行打包。

    第一种具体步骤:

    第一步,非常重要,在父项目中添加packaging标签

    <packaging>pom</packaging>
    

    第二步,使用mvn 生成 项目

    第三步,将子项目用idea,new->module from existing sources 导入

    这样就可以单独在右侧maven中,使用install,clean等命令单独对子项目进行打包,测试。

    在这里插入图片描述

    具体参数配置,在下一篇博客。

    小结

    在学习jvm中,课程中讲到了JMH使用,但是没办法运行。于是参考了jenkov,以及zzh.特此做一下记录,希望能帮助和我一样的新手,先把项目跑起来。

    展开全文
  • Java JMH基准教程

    2020-06-04 03:25:37
    JMH 要使用JHM,我们需要声明jmh-core和jmh-generator-annprocess (JMH注释) pom.xml 1.21 org.openjdk.jmh jmh-core ${jmh.version} org.openjdk.jmh jmh-generator-annprocess ${jmh.version} 2. JMH – Mode...
  • org.openjdk.jmh</groupId> <artifactId>jmh-core</artifactId> <version>${jmh.version}</version> <scope>test</scope> </dependency> <dependency> &...
  • Java基准测试工具JMH使用

    千次阅读 2022-01-26 17:19:21
    JMH,即Java Microbenchmark Harness,这是专门用于进行代码的微基准测试的一套工具API。 JMH 由 OpenJDK/Oracle 里面那群开发了 Java 编译器的大牛们所开发 。何谓 Micro Benchmark 呢? 简单地说就是在 方法层面上...
  • jmh-core-1.3.3.zip

    2019-09-26 04:59:47
    bower-maven-plugin.zip,用于处理来自maven的bower依赖项的插件用于处理来自maven的bower依赖项的插件
  • 基准测试框架JMH使用详解

    千次阅读 2021-02-07 15:00:03
    JMH简介 JMH即Java Microbenchmark Harness,是Java用来做基准测试...创建一个基准测试项目,在项目中引入JMH的jar,目前JMH的最新版本为1.23。以maven为例,依赖配置如下。 <dependencies> <dependency
  • 这篇文章描述了如何设置和运行简单的JMH基准测试。 众所周知,微基准测试很难正确设置,即使您确实正确设置了(通过使用JMH之类的工具),它们仍然会产生误导。 仅仅因为您的代码在极端孤立的人为情况下以某种方式...
  • jmh-样本 一些 JMH - Java Microbenchmark Harness Samples 包含一些 JMH 示例代码。 地图推杆 比较 ConcurrentHashMap 与同步映射 原子基准 比较 AtomicLong 与 LongAdder 随机基准 比较 Random 与 ...
  • JMH基准测试

    2021-12-29 16:34:24
    方式一:通过命令使用Maven命令执行 这种适合对于大型基准测试,像那些要运行很多次,并且运行的时间也比较长的情况下 我们可以直接打个jar,发到服务器上,敲个命令就不用管它,过几十分钟、几个小时甚至几天的...
  • benchmarking-gradle-jmh

    2021-05-17 03:39:31
    基准Gradle JMH样本 样本: jmh-gradle-plugin:0.4.5 jmh-core:1.21 最佳完整样本位于: :
  • eclipse 使用jmh

    2021-09-03 11:03:12
    如果想进行精确测试还需要使用jmh,其全名为Java Microbenchmark Harness,是由 java 虚拟机团队开发的一款用于 java 微基准测试工具。jmh包含多种测试维度,使用也比较简单。 常用注解 @BenchmarkMode:对应Mode...
  • JMH使用指南

    千次阅读 2019-06-28 18:19:28
    关于JMH,可以直接查看官网地址http://openjdk.java.net/projects/code-tools/jmh/ 本博客内容来自我正在撰写的新书《Java性能优化(暂定名)》,也欢迎购买经典书《Spring Boot 2 实战权威指南》 1.3 JMH 1.3.1 ...
  • JMH基准测试和JMH-Visual-chart可视化

    千次阅读 2019-01-10 22:30:01
    如何度量一段代码的性能,换种实现方式会有更佳的性能表现吗?你或许想知道fastjson是否正如它自己所说的那样至今性能未遇对手?Fork/Join框架真的有提高性能吗?...JMH(Java Microbenchmark Harness)是由...
  • jmh-core-1.9.3.jar

    2022-02-25 10:49:17
    java运行依赖jar
  • JMH探索

    2021-10-07 18:41:05
    JMH探索 一、JMH基本介绍 1.1 什么是JMH 1.2 JMH入门 二、JMH的基本概念和配置 2.1 例 2.2 基本标签介绍 2.3 控制台输出 2.4 常用模式(Mode) 2.5 迭代(Iteration) 2.6 预热(Warmup) 2.7 配置类...
  • 为了能够更好地使用 JMH 的各项功能,下面对 JMH 的基本概念进行讲解: @BenchmarkMode 用来配置 Mode 选项,可用于类或者方法上,这个注解的 value 是一个数组, 可以把几种 Mode 集合在一起执行,如:@...
  • 这是一篇学习 JMH 微基准测试框架的笔记。
  • JMH简介

    千次阅读 2018-07-20 14:20:00
    JMH是新的microbenchmark(微基准测试)框架(2013年首次发布)。与其他众多框架相比它的特色优势在于,它是由Oracle实现JIT的相同人员开发的。特别是我想提一下Aleksey Shipilev和他优秀的博客文章。JMH可能与最新...
  • jmh demo

    2021-12-21 19:05:40
    简单实现 jmh demo
  • jmh-基准 此 repo 用于通过使用 JMH 作为微基准测试框架来比较旧式数组循环和 java 8 流。... mvn 清洁 java -jar target/benchmarks.jar 您可以使用参数“-wi, -i ...”来排列迭代次数。 有关 jmh 的更多信息:
  • jmh使用笔记

    2020-11-09 13:41:57
    troubleshooting javax.annotation.Generated jdk11及其以上移除了该,可以使用jar替代,具体参见上面pom 一般来说jmh无法直接在IDE里运行,必须先使用maven打成jar然后执行 connect failed: Connection refused ...
  • java运行依赖jar
  • JMH 测试

    2018-01-03 18:13:18
    TimeUnit是java.util.concurrent下面的一个类,表示给定单元粒度的时间段 TimeUnit.DAYS //天 TimeUnit.HOURS //小时 TimeUnit.MINUTES //分钟 TimeUnit.SECONDS //秒 TimeUnit.MILLISECONDS //...
  • 什么是JMH JMH-Java Microbenchmark Harness(Java微基准测试) 用于测试某方法性能到底是好还是不好,换了方法实现之后性能好还是不好。 2013年首发 ...-- JMH的核心 https://mvnrepository.com/ar
  • JMH在性能测试中的使用

    千次阅读 2022-04-29 17:34:05
    JMH 性能测试

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,656
精华内容 662
关键字:

jmh 包