首页 > 编程语言 >Java 中的5个代码性能提升技巧，最高提升近10倍

Java 中的5个代码性能提升技巧，最高提升近10倍

时间：2024-09-30 19:03:16浏览次数：1  
标签：10 Java HashMap Benchmark values 提升 size public String

Java 中的5个代码性能提升技巧，最高提升近10倍

 

文章持续更新，可以关注公众号程序猿阿朗或访问未读代码博客。
本文 Github.com/niumoo/JavaNotes 已经收录,欢迎Star。

这篇文章介绍几个 Java 开发中可以进行性能优化的小技巧，虽然大多数情况下极致优化代码是没有必要的，但是作为一名技术开发者，我们还是想追求代码的更小、更快，更强。如果哪天你发现程序的运行速度不尽人意，可能会想到这篇文章。

提示：我们不应该为了优化而优化，这有时会增加代码的复杂度。

这篇文章中的代码都在以下环境中进行性能测试。

  • JMH version: 1.33（Java 基准测试框架）
  • VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724

通过这篇文章的测试，将发现以下几个操作的性能差异。

  1. 预先分配 HashMap 的大小，提高 1/4 的性能。
  2. 优化 HashMap 的 key，性能相差 9.5 倍。
  3. 不使用 Enum.values() 遍历，Spring 也曾如此优化。
  4. 使用 Enum 代替 String 常量，性能高出 1.5 倍。
  5. 使用高版本 JDK，基础操作有 2-5 倍性能差异。

当前文章属于Java 性能分析优化系列文章，点击可以查看所有文章。

当前文章中的测试使用 JMH 基准测试，相关文章：使用JMH进行Java代码性能测试。

预先分配 HashMap 的大小

HashMap 是 Java 中最为常用的集合之一，大多数的操作速度都非常快，但是 HashMap 在调整自身的容量大小时是很慢且难以自动优化，因此我们在定义一个 HashMap 之前，应该尽可能的给出它的容量大小。给出 size 值时要考虑负载因子，HashMap 默认负载因子是 0.75，也就是要设置的 size 值要除于 0.75。

相关文章：HashMap 源码分析解读

下面使用 JMH 进行基准测试，测试分别向初始容量为 16 和 32 的 HashMap 中插入 14 个元素的效率。

/**
 * @author https://www.wdbyte.com
 */
@State(Scope.Benchmark)
@Warmup(iterations = 3,time = 3)
@Measurement(iterations = 5,time = 3)
public class HashMapSize {

    @Param({"14"})
    int keys;

    @Param({"16", "32"})
    int size;

    @Benchmark
    public HashMap<Integer, Integer> getHashMap() {
        HashMap<Integer, Integer> map = new HashMap<>(size);
        for (int i = 0; i < keys; i++) {
            map.put(i, i);
        }
        return map;
    }
}

HashMap 的初始容量是 16，负责因子 0.75，即最多插入 12 个元素，再插入时就要进行扩容，所以插入 14 个元素过程中需要扩容一次，但是如果 HashMap 初始化时就给了 32 容量，那么最多可以承载 32 * 0.75 = 24 个元素，所以插入 14 个元素时是不需要扩容操作的。

# JMH version: 1.33
# VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724

Benchmark               (keys)  (size)   Mode  Cnt        Score        Error  Units
HashMapSize.getHashMap      14      16  thrpt   25  4825825.152 ± 323910.557  ops/s
HashMapSize.getHashMap      14      32  thrpt   25  6556184.664 ± 711657.679  ops/s

可以看到在这次测试中，初始容量为32 的 HashMap 比初始容量为 16 的 HashMap 每秒可以多操作 26% 次，已经有 1/4 的性能差异了。

优化 HashMap 的 key

如果 HashMap 的 key 值需要用到多个 String 字符串时，把字符串作为某个类属性，然后使用这个类的实例作为 key 会比使用字符串拼接效率更高。

下面测试使用两个字符串拼接作为 key，和把两个字符串作为 MutablePair 类的属性引用，然后使用 MutablePair 对象作为 key 的运行效率差异。

/**
 * @author https://www.wdbyte.com
 */
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 3)
@Measurement(iterations = 5, time = 3)
public class HashMapKey {

    private int size = 1024;
    private Map<String, Object> stringMap;
    private Map<Pair, Object> pairMap;
    private String[] prefixes;
    private String[] suffixes;

    @Setup(Level.Trial)
    public void setup() {
        prefixes = new String[size];
        suffixes = new String[size];
        stringMap = new HashMap<>();
        pairMap = new HashMap<>();
        for (int i = 0; i < size; ++i) {
            prefixes[i] = UUID.randomUUID().toString();
            suffixes[i] = UUID.randomUUID().toString();
            stringMap.put(prefixes[i] + ";" + suffixes[i], i);
            // use new String to avoid reference equality speeding up the equals calls
            pairMap.put(new MutablePair(prefixes[i], suffixes[i]), i);
        }
    }

    @Benchmark
    @OperationsPerInvocation(1024)
    public void stringKey(Blackhole bh) {
        for (int i = 0; i < prefixes.length; i++) {
            bh.consume(stringMap.get(prefixes[i] + ";" + suffixes[i]));
        }
    }

    @Benchmark
    @OperationsPerInvocation(1024)
    public void pairMap(Blackhole bh) {
        for (int i = 0; i < prefixes.length; i++) {
            bh.consume(pairMap.get(new MutablePair(prefixes[i], suffixes[i])));
        }
    }
}

测试结果：

# JMH version: 1.33
# VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724

Benchmark              Mode  Cnt         Score         Error  Units
HashMapKey.pairMap    thrpt   25  89295035.436 ± 6498403.173  ops/s
HashMapKey.stringKey  thrpt   25   9410641.728 ±  389850.653  ops/s

可以发现使用对象引用作为 key 的性能，是使用 String 拼接作为 key 的性能的 9.5 倍。

不使用 Enum.values() 遍历

我们通常会使用 Enum.values() 进行枚举类遍历，但是这样每次调用都会分配枚举类值数量大小的数组用于操作，这里完全可以缓存起来，以减少每次内存分配的时间和空间消耗。

/**
 * 枚举类遍历测试
 *
 * @author https://www.wdbyte.com
 */
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 3)
@Measurement(iterations = 5, time = 3)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class EnumIteration {
    enum FourteenEnum {
        a,b,c,d,e,f,g,h,i,j,k,l,m,n;

        static final FourteenEnum[] VALUES;
        static {
            VALUES = values();
        }
    }

    @Benchmark
    public void valuesEnum(Blackhole bh) {
        for (FourteenEnum value : FourteenEnum.values()) {
            bh.consume(value.ordinal());
        }
    }

    @Benchmark
    public void enumSetEnum(Blackhole bh) {
        for (FourteenEnum value : EnumSet.allOf(FourteenEnum.class)) {
            bh.consume(value.ordinal());
        }
    }

    @Benchmark
    public void cacheEnums(Blackhole bh) {
        for (FourteenEnum value : FourteenEnum.VALUES) {
            bh.consume(value.ordinal());
        }
    }
}

运行结果

# JMH version: 1.33
# VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724

Benchmark                   Mode  Cnt         Score         Error  Units
EnumIteration.cacheEnums   thrpt   25  15623401.567 ± 2274962.772  ops/s
EnumIteration.enumSetEnum  thrpt   25   8597188.662 ±  610632.249  ops/s
EnumIteration.valuesEnum   thrpt   25  14713941.570 ±  728955.826  ops/s

很明显使用缓存后的遍历速度是最快的，使用 EnumSet 遍历效率是最低的，这很好理解，数组的遍历效率是大于哈希表的。

可能你会觉得这里使用 values() 缓存和直接使用 Enum.values() 的效率差异很小，其实在某些调用频率很高的场景下是有很大区别的，在 Spring 框架中，曾使用 Enum.values() 这种方式在每次响应时遍历 HTTP 状态码枚举类，这在请求量大时造成了不必要的性能开销，后来进行了 values() 缓存优化。

下面是这次提交的截图：

使用 Enum 代替 String 常量

使用 Enum 枚举类代替 String 常量有明显的好处，枚举类强制验证，不会出错，同时使用枚举类的效率也更高。即使作为 Map 的 key 值来看，虽然 HashMap 的速度已经很快了，但是使用 EnumMap 的速度可以更快。

提示：不要为了优化而优化，这会增加代码的复杂度。

下面测试使用使用 Enum 作为 key，和使用 String 作为 key，在 map.get 操作下的性能差异。

/**
 * @author https://www.wdbyte.com
 */
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 3)
@Measurement(iterations = 5, time = 3)
public class EnumMapBenchmark {

    enum AnEnum {
        a, b, c, d, e, f, g,
        h, i, j, k, l, m, n,
        o, p, q,    r, s, t,
        u, v, w,    x, y, z;
    }

    /** 要查找的 key 的数量 */
    private static int size = 10000;
    /** 随机数种子 */
    private static int seed = 99;

    @State(Scope.Benchmark)
    public static class EnumMapState {
        private EnumMap<AnEnum, String> map;
        private AnEnum[] values;

        @Setup(Level.Trial)
        public void setup() {
            map = new EnumMap<>(AnEnum.class);
            values = new AnEnum[size];
            AnEnum[] enumValues = AnEnum.values();
            SplittableRandom random = new SplittableRandom(seed);
            for (int i = 0; i < size; i++) {
                int nextInt = random.nextInt(0, Integer.MAX_VALUE);
                values[i] = enumValues[nextInt % enumValues.length];
            }
            for (AnEnum value : enumValues) {
                map.put(value, UUID.randomUUID().toString());
            }
        }
    }

    @State(Scope.Benchmark)
    public static class HashMapState{
        private HashMap<String, String> map;
        private String[] values;

        @Setup(Level.Trial)
        public void setup() {
            map = new HashMap<>();
            values = new String[size];
            AnEnum[] enumValues = AnEnum.values();
            int pos = 0;
            SplittableRandom random = new SplittableRandom(seed);
            for (int i = 0; i < size; i++) {
                int nextInt = random.nextInt(0, Integer.MAX_VALUE);
                values[i] = enumValues[nextInt % enumValues.length].toString();
            }
            for (AnEnum value : enumValues) {
                map.put(value.toString(), UUID.randomUUID().toString());
            }
        }
    }

    @Benchmark
    public void enumMap(EnumMapState state, Blackhole bh) {
        for (AnEnum value : state.values) {
            bh.consume(state.map.get(value));
        }
    }

    @Benchmark
    public void hashMap(HashMapState state, Blackhole bh) {
        for (String value : state.values) {
            bh.consume(state.map.get(value));
        }
    }
}

运行结果:

# JMH version: 1.33
# VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724

Benchmark                  Mode  Cnt      Score      Error  Units
EnumMapBenchmark.enumMap  thrpt   25  22159.232 ± 1268.800  ops/s
EnumMapBenchmark.hashMap  thrpt   25  14528.555 ± 1323.610  ops/s

很明显，使用 Enum 作为 key 的性能比使用 String 作为 key 的性能高出 1.5 倍。但是仍然要根据实际情况考虑是否使用 EnumMap 和 EnumSet。

使用高版本 JDK

String 类应该是 Java 中使用频率最高的类了，但是 Java 8 中的 String 实现相比高版本 JDK ，则占用空间更多，性能更低。

下面测试 String 转 bytes 和 bytes 转 String 在 Java 8 以及 Java 11 中的性能开销。

/**
 * @author https://www.wdbyte.com
 * @date 2021/12/23
 */
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 3)
@Measurement(iterations = 5, time = 3)
public class StringInJdk {

    @Param({"10000"})
    private int size;
    private String[] stringArray;
    private List<byte[]> byteList;

    @Setup(Level.Trial)
    public void setup() {
        byteList = new ArrayList<>(size);
        stringArray = new String[size];
        for (int i = 0; i < size; i++) {
            String uuid = UUID.randomUUID().toString();
            stringArray[i] = uuid;
            byteList.add(uuid.getBytes(StandardCharsets.UTF_8));
        }
    }

    @Benchmark
    public void byteToString(Blackhole bh) {
        for (byte[] bytes : byteList) {
            bh.consume(new String(bytes, StandardCharsets.UTF_8));
        }
    }

    @Benchmark
    public void stringToByte(Blackhole bh) {
        for (String s : stringArray) {
            bh.consume(s.getBytes(StandardCharsets.UTF_8));
        }
    }
}

测试结果：

# JMH version: 1.33
# VM version: JDK 1.8.0_151, Java HotSpot(TM) 64-Bit Server VM, 25.151-b12

Benchmark                 (size)   Mode  Cnt     Score     Error  Units
StringInJdk.byteToString   10000  thrpt   25  2396.713 ± 133.500  ops/s
StringInJdk.stringToByte   10000  thrpt   25  1745.060 ±  16.945  ops/s

# JMH version: 1.33
# VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724

Benchmark                 (size)   Mode  Cnt     Score     Error  Units
StringInJdk.byteToString   10000  thrpt   25  5711.954 ±  41.865  ops/s
StringInJdk.stringToByte   10000  thrpt   25  8595.895 ± 704.004  ops/s
SHELL 复制 全屏

可以看到在 bytes 转 String 操作上，Java 17 的性能是 Java 8 的 2.5 倍左右，而 String 转 bytes 操作，Java 17 的性能是 Java 8 的 5 倍。关于字符串的操作非常基础，随处可见，可见高版本的优势十分明显。

一如既往，当前文章中的代码示例都存放在 github.com/niumoo/JavaNotes.

参考

订阅

可以微信搜一搜 程序猿阿朗 或访问 程序猿阿朗博客 。

本文 Github.com/niumoo/JavaNotes 已经收录，有很多知识点和系列文章，欢迎Star。

标签：10,Java,HashMap,Benchmark,values,提升,size,public,String
From： https://www.cnblogs.com/sexintercourse/p/18442329

相关文章

  • 什么是javascript的事件循环
    JavaScript的事件循环（EventLoop）是其执行机制的核心，用来处理异步操作，使得JavaScript能够实现非阻塞式的单线程异步编程。为了理解事件循环，首先要了解JavaScript是单线程的语言，这意味着它一次只能执行一个任务。但在实际应用中，比如I/O操作（网络请求、定时器、用户事......
  • Java语言之数据类型与变量
    Java的数据类型主要分为两类基本数据类型：整形（包括：字节型：byte、1个字节,短整型：short、两个字节，整形：int、4个字节，长整型：long、8个字节），字符型：char、一个字节，浮点型（包括：单精度浮点型float、4个字节，双精度浮点型：double、8个字节），布尔类型：boolean,java并没有规定几个字节。java中没有......
  • SCIE1000  Python and Communication
    SCIE1000 Semester 2, 2024Python and Communication Assignment1    The scenarioA new public science museum in St Lucia is developing an exhibit. A feature ofthe museum is that each exhibit item is accompanied by two expla......
  • 发现AI 黑科技，10个工程师的活1个人做？PLM系统还能这样用！
    什么？？？10个工程师的活1个人做？是的，没听错。小编发现一项最新AI黑科技，可以实现哦！根据订单的要求直接输入内容，AI会帮你生成改型设计图纸啦！！到底怎么做的？？？赶紧和我一起来看！AI之文生设计AI融合一举多得通过对设计场景进行重构，系统化整理改型设计知识，赋予AI设计核心逻辑，简化......
  • 缓存雪崩/穿透/击穿/失效原理图/14种缓存数据特征+10种数据一致性方案（专家篇）
    在当今数据驱动的互联网时代，缓存成为了提升应用性能的关键技术。面对海量用户请求，如何通过缓存策略有效减轻数据库压力、降低响应延迟？本文深入探讨了缓存雪崩、缓存穿透、缓存击穿等常见问题，并提供了全面的解决方案。通过实际案例分析，揭示了缓存设计的最佳实践，确保数据一致......
  • UOS 1070/Deepin 23环境下安装Master PDF Editor 5.8.35
    在UOS1070环境下，有福昕PDF编辑器可以使用，但是升级到Deepinv23之后，福昕编辑器就无法安装了，需要换工具。比较好用的就是MasterPDFEditor，安装注册也非常简单，现在写到这里，作为记录。#目前最方便安装的是master-pdf-editor-5.9.35版本，UOS和Deepinv23都支持wgethttps://code-......
  • 10789 神秘指数 数组 枚举 check
    解决思路 计算总和：首先计算所有神秘物品的神秘指数和 sum。 枚举分组数：从 n 开始枚举分组数 i，尝试将神秘物品分成 i 组。 检查分组可行性：对于每个分组数 i，检查是否可以将神秘物品分成 i 组且每组的神秘指数和相同。 输出结果：找到最小的可行分组数 i，......
  • [Java手撕]读取文件并进行left join操作
    importjava.io.*;importjava.sql.Time;importjava.util.*;importjava.util.concurrent.*;importjava.util.concurrent.atomic.AtomicInteger;importjava.util.concurrent.locks.Condition;importjava.util.concurrent.locks.ReentrantLock;publicclassMain......
  • Java开发中操作日志的作用和模块
     Java中的操作日志模块的开发和运行维护都是十分耗时耗力。操作日志的收集涉及到公司的项目或者是上市产品的用户体验和反馈。后端和前端开发工程师的日常工作就是对运行维护工程师收集回来的项目和产品的反馈进行系统级别的分析以及需求下发迭代开发。操作日志的打印方式分为线......
  • idea2023-快速搭建一个本地tomcat的javaWeb项目（从0到1保姆教学）
    前言如何在新版idea中搭建一个javaWeb项目，并且应用在物理的tomcat中，本文将进行从零到一，完成搭建步骤，以及相关注意事项的讲解。为什么需要配置tomcat？我们开发的javaWeb项目，最后都需要打包部署到真正的物理tomcat上发布运行；在开发阶段，我们想要测试javaWeb项目，除了使用maven......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99