首页 / JAVA / 基准测试神器 - JMH [ Java Microbenchmark Harness ]

JMH，全称 Java Microbenchmark Harness (微基准测试框架），是专门用于Java代码微基准测试的一套测试工具API，是由 OpenJDK/Oracle 官方发布的工具。其精度可以达到毫秒级.可以执行一个函数需要多少时间,或者一个算法有多种不同实现等情况下,选择一个性能最好的那个.

Java的基准测试需要注意的几个点：

测试前需要预热。

防止无用代码进入测试方法中。

并发测试。

测试结果呈现。

预热？为什么要预热？ ???????????

因为 JVM 的 JIT 机制的存在，如果某个函数被调用多次之后，JVM 会尝试将其编译成为机器码从而提高执行速度。为了让 benchmark 的结果更加接近真实情况就需要进行预热。

JMH的使用场景：

定量分析某个热点函数的优化效果

想定量地知道某个函数需要执行多长时间，以及执行时间和输入变量的相关性

对比一个函数的多种实现方式

二. 安装 [ idea plug ]

2.1 直接在Plugins的面板搜索 JMH 安装JMH plugin .

基准测试神器 - JMH [ Java Microbenchmark Harness ] - 文章图片

2.2 配置idea , 即可.

基准测试神器 - JMH [ Java Microbenchmark Harness ] - 文章图片

三. 注解

@Benchmark

@Benchmark标签是用来标记测试方法的，只有被这个注解标记的话，该方法才会参与基准测试，但是有一个基本的原则就是被@Benchmark标记的方法必须是public的。

@Warmup

@Warmup用来配置预热的内容，可用于类或者方法上，越靠近执行方法的地方越准确。一般配置warmup的参数有这些：

iterations：预热的次数。
time：每次预热的时间。
timeUnit：时间单位，默认是s。
batchSize：批处理大小，每次操作调用几次方法。（后面用到）

@Measurement

用来控制实际执行的内容，配置的选项本warmup一样。

@BenchmarkMode

@BenchmarkMode主要是表示测量的维度，有以下这些维度可供选择：

Mode.Throughput 吞吐量维度

Mode.AverageTime 平均时间

Mode.SampleTime 抽样检测

Mode.SingleShotTime 检测一次调用

Mode.All 运用所有的检测模式在方法级别指定@BenchmarkMode的时候可以一定指定多个纬度，例如： @BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime, Mode.SingleShotTime})，代表同时在多个纬度对目标方法进行测量。

@OutputTimeUnit

@OutputTimeUnit代表测量的单位，比如秒级别，毫秒级别，微妙级别等等。一般都使用微妙和毫秒级别的稍微多一点。该注解可以用在方法级别和类级别，当用在类级别的时候会被更加精确的方法级别的注解覆盖，原则就是离目标更近的注解更容易生效。

@State

在很多时候我们需要维护一些状态内容，比如在多线程的时候我们会维护一个共享的状态，这个状态值可能会在每隔线程中都一样，也有可能是每个线程都有自己的状态，JMH为我们提供了状态的支持。该注解只能用来标注在类上，因为类作为一个属性的载体。 @State的状态值主要有以下几种：

Scope.Benchmark 该状态的意思是会在所有的Benchmark的工作线程中共享变量内容。

Scope.Group 同一个Group的线程可以享有同样的变量

Scope.Thread 每隔线程都享有一份变量的副本，线程之间对于变量的修改不会相互影响。

下面看两个常见的@State的写法：

1.直接在内部类中使用@State作为“PropertyHolder”

public class JMHSample_03_States {

    @State(Scope.Benchmark)
    public static class BenchmarkState {
        volatile double x = Math.PI;
    }

    @State(Scope.Thread)
    public static class ThreadState {
        volatile double x = Math.PI;
    }

    @Benchmark
    public void measureUnshared(ThreadState state) {
        state.x++;
    }

    @Benchmark
    public void measureShared(BenchmarkState state) {
        state.x++;
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JMHSample_03_States.class.getSimpleName())
                .threads(4)
                .forks(1)
                .build();

        new Runner(opt).run();
    }
}

2.在Main类中直接使用@State作为注解，是Main类直接成为“PropertyHolder”
@State(Scope.Thread)
public class JMHSample_04_DefaultState {
    double x = Math.PI;

    @Benchmark
    public void measure() {
        x++;
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JMHSample_04_DefaultState.class.getSimpleName())
                .forks(1)
                .build();

        new Runner(opt).run();
    }
}

我们试想以下@State的含义，它主要是方便框架来控制变量的过程逻辑，通过@State标示的类都被用作属性的容器，然后框架可以通过自己的控制来配置不同级别的隔离情况。被@Benchmark标注的方法可以有参数，但是参数必须是被@State注解的，就是为了要控制参数的隔离。

但是有些情况下我们需要对参数进行一些初始化或者释放的操作，就像Spring提供的一些init和destory方法一样，JHM也提供有这样的钩子：

@Setup 必须标示在@State注解的类内部，表示初始化操作
@TearDown 必须表示在@State注解的类内部，表示销毁操作

初始化和销毁的动作都只会执行一次。



import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.Options;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;


@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 2 轮，每次 1s
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 测试 5 轮，每次 3s
@Fork(1) // fork 1 个线程
@State(Scope.Thread) // 每个测试线程一个实例
public class JMHSample_05_StateFixtures {
    double x;

    @Setup
    public void prepare() {
        System.out.println("This is Setup ");
        x = Math.PI;
    }

    @TearDown
    public void check() {
        System.out.println("This is TearDown ");
        assert x > Math.PI : "Nothing changed?";
    }

    @Benchmark
    public void measureRight() {
        x++;
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JMHSample_05_StateFixtures.class.getSimpleName())
                .forks(1)
                .jvmArgs("-ea")
                .build();

        new Runner(opt).run();
    }
}

虽然我们可以执行初始化和销毁的动作，但是总是感觉还缺点啥？对，就是初始化的粒度。因为基准测试往往会执行多次，那么能不能保证每次执行方法的时候都初始化一次变量呢？ @Setup和@TearDown提供了以下三种纬度的控制：

Level.Trial 只会在个基础测试的前后执行。包括Warmup和Measurement阶段，一共只会执行一次。

Level.Iteration 每次执行记住测试方法的时候都会执行，如果Warmup和Measurement都配置了2次执行的话，那么@Setup和@TearDown配置的方法的执行次数就4次。

Level.Invocation 每个方法执行的前后执行（一般不推荐这么用）

@Param

在很多情况下，我们需要测试不同的参数的不同结果，但是测试的了逻辑又都是一样的，因此如果我们编写镀铬benchmark的话会造成逻辑的冗余，幸好JMH提供了@Param参数来帮助我们处理这个事情，被@Param注解标示的参数组会一次被benchmark消费到。

@State(Scope.Benchmark)
public class ParamTest {

    @Param({"1", "2", "3"})
    int testNum;

    @Benchmark
    public String test() {
        return String.valueOf(testNum);
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(ParamTest.class.getSimpleName())
                .forks(1)
                .build();

        new Runner(opt).run();
    }
}

@Threads

测试线程的数量，可以配置在方法或者类上，代表执行测试的线程数量。

通常看到这里我们会比较迷惑Iteration和Invocation区别，我们在配置Warmup的时候默认的时间是的1s，即1s的执行作为一个Iteration，假设每次方法的执行是100ms的话，那么1个Iteration就代表10个Invocation。

四.使用样例

4.1.修改pom.xml配置文件

   <dependencies>
        <!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-core -->
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>1.23</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-generator-annprocess -->
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>1.23</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

4.2.测试map的循环输出效率

4.2.1.代码

package com.map;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.Options;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 2 轮，每次 1s
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 测试 5 轮，每次1s
@Fork(1) // fork 1 个线程
@State(Scope.Thread) // 每个测试线程一个实例
public class HashMapTest {
    static Map<Integer, String> map = new HashMap() {{
        // 添加数据
        for (int i = 0; i < 10000; i++) {
            put(i, "val:" + i);
        }
    }};

    public static void main(String[] args) throws RunnerException {
        // 启动基准测试
        Options opt = new OptionsBuilder()
                .include(HashMapTest.class.getSimpleName()) // 要导入的测试类
//                .output("/a/jmh-map.log") // 输出测试结果的文件
                .build();
        new Runner(opt).run(); // 执行测试
    }

    @Benchmark
    public void entrySet() {
        // 遍历
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            Integer k = entry.getKey();
            String v = entry.getValue();
        }
    }

    @Benchmark
    public void forEachEntrySet() {
        // 遍历
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            Integer k = entry.getKey();
            String v = entry.getValue();
        }
    }

    @Benchmark
    public void keySet() {
        // 遍历
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            Integer k = iterator.next();
            String v = map.get(k);
        }
    }

    @Benchmark
    public void forEachKeySet() {
        // 遍历
        for (Integer key : map.keySet()) {
            Integer k = key;
            String v = map.get(k);
        }
    }

    @Benchmark
    public void lambda() {
        // 遍历
        map.forEach((key, value) -> {
            Integer k = key;
            String v = map.get(k);
        });
    }

    @Benchmark
    public void streamApi() {
        // 单线程遍历
        map.entrySet().stream().forEach((entry) -> {
            Integer k = entry.getKey();
            String v = entry.getValue();
        });
    }

    public void parallelStreamApi() {
        // 多线程遍历
        map.entrySet().parallelStream().forEach((entry) -> {
            Integer k = entry.getKey();
            String v = entry.getValue();
        });
    }
}

4.2.2.结果:

尽量使用 map.entrySet() 进行输出. 因为性能方面照普通的循环快将近2倍.

Benchmark                    Mode  Cnt      Score       Error  Units
HashMapTest.entrySet         avgt    5  47831.209 ± 14037.126  ns/op
HashMapTest.forEachEntrySet  avgt    5  56189.356 ± 16866.246  ns/op
HashMapTest.forEachKeySet    avgt    5  75973.584 ±  7738.707  ns/op
HashMapTest.keySet           avgt    5  76458.791 ± 11008.914  ns/op
HashMapTest.lambda           avgt    5  80734.554 ±  9695.806  ns/op
HashMapTest.streamApi        avgt    5  49939.633 ± 11131.095  ns/op

4.2.3.原因.

EntrySet 之所以比 KeySet 的性能高是因为，KeySet 在循环时使用了 map.get(key)，而 map.get(key) 相当于又遍历了一遍 Map 集合去查询 key 所对应的值。为什么要用“又”这个词？那是因为在使用迭代器或者 for 循环时，其实已经遍历了一遍 Map 集合了，因此再使用 map.get(key) 查询时，相当于遍历了两遍。

而 EntrySet 只遍历了一遍 Map 集合，之后通过代码“Entry<Integer, String> entry = iterator.next()”把对象的 key 和 value 值都放入到了 Entry 对象中，因此再获取 key 和 value 值时就无需再遍历 Map 集合，只需要从 Entry 对象中取值就可以了。

所以，EntrySet 的性能比 KeySet 的性能高出了一倍，因为 KeySet 相当于循环了两遍 Map 集合，而 EntrySet 只循环了一遍。

4.3.测试list的循环效果

4.3.1.代码

package list;


import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.Options;

import java.util.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 2 轮，每次 1s
@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS) // 测试 5 轮，每次 3s
@Fork(1) // fork 1 个线程
@State(Scope.Thread) // 每个测试线程一个实例
public class ListTest {

    static LinkedList<Integer> linkedList = new LinkedList<Integer>(){
        {
            // 添加数据
            for (int i = 0; i < 10000; i++) {
                add(i);
            }
        }
    };

    static ArrayList<Integer> arrayList = new ArrayList<Integer>(){
        {
            // 添加数据
            for (int i = 0; i < 10000; i++) {
                add(i);
            }
        }
    };


    public static void main(String[] args) throws RunnerException {
        // 启动基准测试
        Options opt = new OptionsBuilder()
                .include(ListTest.class.getSimpleName()) // 要导入的测试类
//                .output("/a/jmh-map.log") // 输出测试结果的文件
                .build();
        new Runner(opt).run(); // 执行测试
    }

    @Benchmark
    public void linkedListFor() {
        // 遍历
        for (int i = 0 ; i < linkedList.size() ; i++) {
            int x = linkedList.get(i);
        }
    }

    @Benchmark
    public void linkedListForEach() {
        // 遍历
        for (Integer i  : linkedList ) {

        }
    }

    @Benchmark
    public void arrayListFor() {
        // 遍历
        for (int i = 0 ; i < arrayList.size() ; i++) {
            int x = arrayList.get(i);
        }
    }

    @Benchmark
    public void arrayListForEach() {
        // 遍历
        for (Integer i  : arrayList ) {

        }
    }

}

4.3.2. 结果

Benchmark                   Mode  Cnt         Score         Error  Units
ListTest.arrayListFor       avgt    5      7291.515 ±    1348.462  ns/op
ListTest.arrayListForEach   avgt    5      6955.242 ±    1587.509  ns/op
ListTest.linkedListFor      avgt    5  41467520.339 ± 8443367.361  ns/op
ListTest.linkedListForEach  avgt    5     22096.751 ±    6459.100  ns/op

五.官方网站&示例

官网: https://openjdk.java.net/projects/code-tools/jmh/

git hub idea-jmh-plugin : https://github.com/artyushov/idea-jmh-plugin

示例: https://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/

基准测试神器 - JMH [ Java Microbenchmark Harness ] - 文章图片

内容总结

以上是互联网集市为您收集整理的基准测试神器 - JMH [ Java Microbenchmark Harness ]全部内容，希望文章能够帮你解决基准测试神器 - JMH [ Java Microbenchmark Harness ]所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/632539.html

来源：【匿名】

【上一篇】小白，你要的Java抽象类，操碎了心！【下一篇】JAVA/JSP学习系列之五

更多 ►

【基准测试神器 - JMH [ Java Microbenchmark Harness ]】教程文章相关的互联网学习教程文章

java的基准测试

一：for循环和java8的性能比较如下：// 一个大的 ArrayList，内部是随机的整形数据volatile List<Integer> integers = … // 基准测试 1public int forEachLoopMaxInteger() { int max = Integer.MIN_VALUE; for (Integer n : integers) { max = Integer.max(max, n); } return max;} // 基准测试 2public int lambdaMaxInteger() { return integers.stream().reduce(Integer.MIN_VALUE, (a, b) -> Integer.max(a, ...

mysql基准测试，java测试《续》

测试，详细地写下测试规划也是必须的。 3.应该建立将参数和结果文档化的规范，每一办测试都必须进行详细记录。二、基准测试的运行时间（运行多长时间合适，多少次）三、获取系统性能和状态（cpu 使用率，磁盘I/0,网络流量统计，SHOW GLOBAL STATUS 计数器等）四、获得准确的测试结果（一般情况下，都是通过迭代逐步地修改基准的测试参数，而不是每次运行时都做大量的修改）mysql基准测试，java测试《续》标签：本文系...

基准测试神器 - JMH [ Java Microbenchmark Harness ]【代码】【图】

Table of Contents 一. 简介二. 安装 [ idea plug ] 三. 注解 @Benchmark @Warmup @Measurement @BenchmarkMode @OutputTimeUnit @State @Param @Threads 四.使用样例 4.1.修改pom.xml配置文件 4.2.测试map的循环输出效率 4.2.1.代码 4.2.2.结果: 4.2.3.原因. 4.3.测试list的循环效果 4.3.1.代码 4.3.2. 结果五.官方网站&示例一. 简介 JMH，全称 Java Microbenchmark Harness (微基准测试框架），是专门用于Java代...

JMH java基准测试【代码】

maven依赖 <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.source...

Java12新特性 -- 微基准测试套件

JMH，即Java Microbenchmark Harness，是专门用于代码微基准测试的工具套件。何谓Micro Benchmark呢？简单的来说就是基于方法层面的基准测试，精度可以达到微秒级。当你定位到热点方法，希望进一步优化方法性能的时候，就可以使用JMH对优化的结果进行量化的分析。 JMH比较典型的应用场景：想准确的知道某个方法需要执行多长时间，以及执行时间和输入之间的相关性；对比接口不同实现在给定条件下的吞吐量；查看多少百分比的请求在...

java – 是否可以在外部探查器下运行JMH基准测试？

我现在正在打猎.为了衡量吞吐量,并强制我们不退步,我正在使用精彩的JMH. 当我遇到一些缓慢的东西时,我想开始分析以查看发生了什么,根据JMH的作者this link写道：While JMH profilers can provide the aid in analyzing, I don’t think theyare the substitute for proper profiling. E.g. the “stack” profiler isgood to glance over the profiles, but not for the serious work. Run the workload for longer, and attach y...

java – jmh：同时运行基准测试【代码】

我正在运行jmh benchmark,但每个试验中的调用都是连续发生的.如何让调用同时运行？这是我的代码的摘要： @State(Scope.Benchmark) public class FooBenchmark {@Param({"123456"})public int barId;@Setuppublic void setup() {}@Benchmarkpublic void run(Blackhole hole) {System.out.println("A"); // for proof that it's serial (see below)...System.out.println("B"); // for proof that it's serial (see below)} }这将...

Java Spring Batch与Apache Spark基准测试中的ETL

我已经使用Apache Spark Scala超过5年了(学术和专业经验).我总是发现Spark / Scala是用于构建任何类型的批处理或流式ETL / ELT应用程序的强大组合之一. 但最近,我的客户决定在我们的两个主要管道中使用Java Spring Batch： >从MongoDB中读取 – >业务逻辑 – >写入JSON文件(~2GB | 600k行)>阅读Cassandra – >业务逻辑 – >写JSON文件(~4GB | 2M行) 这个企业级决策令我感到非常困惑.我同意业内有更多的思想,但我无法理解采取这一行...

Java Web框架基准测试

为了与django进行比较,我想在主要的Java Web框架(struts,faces等等)上找到基准测试.我搜索谷歌,但我无法找到一个基准,给出了多少req / s java框架可以处理. 你知道java web框架的一些基准吗？解决方法:Techempower基准： http://www.techempower.com/benchmarks 他们正在比较许多框架并接受新的框架进行比较.界面非常直观.在我看来,它现在是最好的基准. 世界各地的等待 – 1小时的演讲 http://www.parleys.com/#id=2942&st=5 Djan...

是否有Java LZO与Deflate vs. Gzip的基准测试？

LZO的(非常过时的)页面包含指向Java实现的链接.还有一个模糊的承诺：“新…… Java ……接口……在不久的将来某个时候.”但我相信这已经存在了几年. 这让我觉得旧的LZO Java实现可能很慢.是否有任何基准测量性能,以及它与其他压缩机的相对性能(例如,放气)？解决方法:我已将最新的minilzo.c移植到java.初始版本是http://code.google.com/p/java-compress/.我很快就会为我的端口添加基于java的基准测试. 问候马哈德

用java创建快速/可靠的基准测试？【代码】

我正在尝试用java创建基准测试.目前我有以下简单的方法：public static long runTest(int times){long start = System.nanoTime(); String str = "str";for(int i=0; i<times; i++){str = "str"+i;} return System.nanoTime()-start; }我目前在另一个多次发生的循环中多次进行此循环,并获得运行此方法所需的最小/最大/平均时间.然后我在另一个线程上开始一些活动并再次测试.基本上我只想获得一致的结果……如果我有...

java – 如何在Android或性能基准测试中获取对象的内存大小？

长话短说,我想测试我的android.os.Bundle类的克隆实现反对那个班级,看看哪个更好.我已经知道我的版本可能会更糟,但我想知道有多糟糕.是否有适用于Android的基准测试工具,我可以使用它来查看哪个对象在内存中更大和/或需要更多处理时间来存储/检索值？ TL; DR：我查看了android.os.Bundle类的源代码,我不喜欢它如何存储和返回对象.它只是将它们存储在HashMap< String,Object>中.然后使用ClassLoader强制转换为请求对象的类(如getSt...

如何真正基准测试Java应用程序的内存使用情况【代码】

我想在内存使用效率方面比较Java程序的不同实现.有不同的使用场景表示为JUnit测试用例.实际上,所有代码都是开源的：https://github.com/headissue/cache2k-benchmark 获取Java程序的已用内存的一般智慧是：Runtime.getRuntime().totalMemory() – Runtime.getRuntime().freeMemory(),当然也可以使用JMX接口来获取这些内容值. 但是,所使用的存储器的确定值不可靠.可能的原因： >可能有未收集的垃圾>如果GC没有压缩,就会出现碎片到...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / 基准测试神器 - JMH [ Java Microbenchmark Harness ]

基准测试神器 - JMH [ Java Microbenchmark Harness ]

内容导读

内容图文

一. 简介

二. 安装 [ idea plug ]

三. 注解

@Benchmark

@Warmup

@Measurement

@BenchmarkMode

@OutputTimeUnit

@State

@Param

@Threads

四.使用样例

4.1.修改pom.xml配置文件

4.2.测试map的循环输出效率

4.2.1.代码

4.2.2.结果:

4.2.3.原因.

4.3.测试list的循环效果

4.3.1.代码

4.3.2. 结果

五.官方网站&示例

内容总结

内容备注

内容手机端

【基准测试神器 - JMH [ Java Microbenchmark Harness ]】教程文章相关的互联网学习教程文章

JAVA - 相关标签

测试 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程