Java的几种创建实例方法的性能对比

  1. 云栖社区>
  2. 博客>
  3. 正文

Java的几种创建实例方法的性能对比

优惠码优惠 2019-07-26 12:14:06 浏览444
展开阅读全文

Java的几种创建实例方法的性能对比
近来打算自己封装一个比较方便读写的Office Excel 工具类,前面已经写了一些,比较粗糙本就计划重构一下,刚好公司的电商APP后台原有的导出Excel实现出现了可怕的性能问题,600行的数据生成Excel工作簿居然需要50秒以上,客户端连接都被熔断了还没导出来,挺巧,那就一起解决吧。

在上一个版本里呢,我认为比较巧妙的地方在于用函数式编程的方式代替反射,很早以前了解了反射的一些底层后我就知道反射的性能很差,但一直没实际测试过各种调用场景的性能差距。

至于底层字节码、CPU指令这些我就不深究了,我还没到那个级别,那这次就来个简单的测试吧。

目标:创建Man对象。

方式:

① 直接引用 new Man();

② 使用反射

③ 使用内部类

④ 使用Lombda表达式

⑤ 使用Method Reference

在学习Java8新特性的时候,我所了解到的是Lombda表达式是内部类的一种简化书写方式,也就是语法糖,但两者间在运行时居然有比较明显的性能差距,让我不得不怀疑它底层到底是啥东西,时间精力有限先记着,有必要的时候再去啃openJDK吧。

还有就是Lombda和Method Reference从表现来看,底层应该是同一个东西,但IDEA既然分开两种内部类的写法推荐,那就分开对待吧。

测试时每种方式循环调用 1 亿次,每种方式连续计算两次时间,然后对比第二次运行的结果,直接run没有采用debug运行。

贴代码:

复制代码
1 package com.supalle.test;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Builder;
5 import lombok.Data;
6 import lombok.NoArgsConstructor;
7
8 import java.lang.reflect.Constructor;
9 import java.lang.reflect.InvocationTargetException;
10 import java.util.function.Supplier;
11
12 /**
13 * @描述:语法PK
14 * @作者:Supalle
15 * @时间:2019/7/26
16 */
17 public class SyntaxPKTest {
18
19
20 / 循环次数 /
21 private final static int SIZE = 100000000;
22
23 / 有类如下 /
24 @Data
25 @Builder
26 @NoArgsConstructor
27 @AllArgsConstructor
28 private static class Man {
29 private String name;
30 private int age;
31 }
32
33
34 /**
35 * 使用 new Man();
36 *
37 * @return 运行耗时
38 */
39 public static long runWithNewConstructor() {
40 long start = System.currentTimeMillis();
41
42 for (int i = 0; i < SIZE; i++) {
43 new SyntaxPKTest.Man();
44 }
45
46 return System.currentTimeMillis() - start;
47 }
48
49 /**
50 * 使用反射
51 *
52 * @return 运行耗时
53 */
54 public static long runWithReflex() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
55 Constructor constructor = SyntaxPKTest.Man.class.getConstructor();
56 long start = System.currentTimeMillis();
57
58 for (int i = 0; i < SIZE; i++) {
59 constructor.newInstance();
60 }
61
62 return System.currentTimeMillis() - start;
63 }
64
65 /**
66 * 使用内部类调用 new Man();
67 *
68 * @return 运行耗时
69 */
70 public static long runWithSubClass() {
71 long start = System.currentTimeMillis();
72
73 for (int i = 0; i < SIZE; i++) {
74 new Supplier() {
75 @Override
76 public SyntaxPKTest.Man get() {
77 return new SyntaxPKTest.Man();
78 }
79 }.get();
80
81 }
82
83 return System.currentTimeMillis() - start;
84 }
85
86 /**
87 * 使用Lambda调用 new Man();
88 *
89 * @return 运行耗时
90 */
91 public static long runWithLambda() {
92 long start = System.currentTimeMillis();
93
94 for (int i = 0; i < SIZE; i++) {
95 ((Supplier) () -> new SyntaxPKTest.Man()).get();
96 }
97
98 return System.currentTimeMillis() - start;
99 }
100
101
102 /**
103 * 使用 MethodReference
104 *
105 * @return 运行耗时
106 */
107 public static long runWithMethodReference() {
108 long start = System.currentTimeMillis();
109
110 for (int i = 0; i < SIZE; i++) {
111 ((Supplier) SyntaxPKTest.Man::new).get();
112 }
113
114 return System.currentTimeMillis() - start;
115 }
116
117 public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
118
119 // 测试前调用一下,加载Man字节码,尽量公平
120 SyntaxPKTest.Man man1 = new SyntaxPKTest.Man();
121 SyntaxPKTest.Man man2 = new SyntaxPKTest.Man("张三", 20);
122
123 System.out.println("测试环境:CPU核心数 - " + Runtime.getRuntime().availableProcessors());
124
125 System.out.println();
126
127 // 这里的话对比再次调用的时间
128 System.out.println("首次使用 new Man() 耗时:" + runWithNewConstructor());
129 System.err.println("再次使用 new Man() 耗时:" + runWithNewConstructor());
130 System.out.println("首次使用反射 耗时:" + runWithReflex());
131 System.err.println("再次使用反射 耗时:" + runWithReflex());
132 System.out.println("首次使用内部类调用 new Man() 耗时:" + runWithSubClass());
133 System.err.println("再次使用内部类调用 new Man() 耗时:" + runWithSubClass());
134 System.out.println("首次使用Lambda调用 new Man() 耗时:" + runWithLambda());
135 System.err.println("再次使用Lambda调用 new Man() 耗时:" + runWithLambda());
136 System.out.println("首次使用 MethodReference 耗时:" + runWithMethodReference());
137 System.err.println("再次使用 MethodReference 耗时:" + runWithMethodReference());
138
139
140 }
141
142 }
复制代码

运行结果:

一:

复制代码
测试环境:CPU核心数 - 8

首次使用 new Man() 耗时:5
再次使用 new Man() 耗时:3
首次使用反射 耗时:312
再次使用反射 耗时:276
首次使用内部类调用 new Man() 耗时:6
再次使用内部类调用 new Man() 耗时:3
首次使用Lambda调用 new Man() 耗时:142
再次使用Lambda调用 new Man() 耗时:100
首次使用 MethodReference 耗时:86
再次使用 MethodReference 耗时:85
复制代码
二:

复制代码
测试环境:CPU核心数 - 8

首次使用 new Man() 耗时:5
再次使用 new Man() 耗时:2
首次使用反射 耗时:326
再次使用反射 耗时:275
首次使用内部类调用 new Man() 耗时:6
再次使用内部类调用 new Man() 耗时:3
首次使用Lambda调用 new Man() 耗时:122
再次使用Lambda调用 new Man() 耗时:86
首次使用 MethodReference 耗时:102
再次使用 MethodReference 耗时:83
复制代码
三:

复制代码
测试环境:CPU核心数 - 8

首次使用 new Man() 耗时:5
再次使用 new Man() 耗时:3
首次使用反射 耗时:322
再次使用反射 耗时:288
首次使用内部类调用 new Man() 耗时:7
再次使用内部类调用 new Man() 耗时:2
首次使用Lambda调用 new Man() 耗时:128
再次使用Lambda调用 new Man() 耗时:92
首次使用 MethodReference 耗时:97
再次使用 MethodReference 耗时:81
复制代码

如果Lambda和MethodReference调换一下位置如下:

复制代码
1      System.out.println("首次使用 new Man() 耗时:" + runWithNewConstructor());
2 System.err.println("再次使用 new Man() 耗时:" + runWithNewConstructor());
3 System.out.println("首次使用反射 耗时:" + runWithReflex());
4 System.err.println("再次使用反射 耗时:" + runWithReflex());
5 System.out.println("首次使用内部类调用 new Man() 耗时:" + runWithSubClass());
6 System.err.println("再次使用内部类调用 new Man() 耗时:" + runWithSubClass());
7 System.out.println("首次使用 MethodReference 耗时:" + runWithMethodReference());
8 System.err.println("再次使用 MethodReference 耗时:" + runWithMethodReference());
9 System.out.println("首次使用Lambda调用 new Man() 耗时:" + runWithLambda());
10 System.err.println("再次使用Lambda调用 new Man() 耗时:" + runWithLambda());
复制代码
一:

复制代码
测试环境:CPU核心数 - 8

首次使用 new Man() 耗时:6
再次使用 new Man() 耗时:2
首次使用反射 耗时:351
再次使用反射 耗时:270
首次使用内部类调用 new Man() 耗时:6
再次使用内部类调用 new Man() 耗时:3
首次使用 MethodReference 耗时:128
再次使用 MethodReference 耗时:97
首次使用Lambda调用 new Man() 耗时:82
再次使用Lambda调用 new Man() 耗时:74
复制代码
二:

复制代码
测试环境:CPU核心数 - 8

首次使用 new Man() 耗时:5
再次使用 new Man() 耗时:3
首次使用反射 耗时:318
再次使用反射 耗时:297
首次使用内部类调用 new Man() 耗时:6
再次使用内部类调用 new Man() 耗时:2
首次使用 MethodReference 耗时:117
再次使用 MethodReference 耗时:100
首次使用Lambda调用 new Man() 耗时:91
再次使用Lambda调用 new Man() 耗时:79
复制代码
三:

复制代码
测试环境:CPU核心数 - 8

首次使用 new Man() 耗时:6
再次使用 new Man() 耗时:3
首次使用反射 耗时:319
再次使用反射 耗时:277
首次使用内部类调用 new Man() 耗时:8
再次使用内部类调用 new Man() 耗时:3
首次使用 MethodReference 耗时:139
再次使用 MethodReference 耗时:85
首次使用Lambda调用 new Man() 耗时:103
再次使用Lambda调用 new Man() 耗时:84
复制代码

总结:

  ① 如果不需要足够的灵活性,直接使用 new 来构造一个对象,效率最高的。

  ② 反射确确实实是垫底,当然它也给我们提供了足够全面的、灵活的类操纵能力。

  ③ 使用内部类的方式,效率上和直接new 非常贴近,虽然看起来代码多一些,但是足够灵活。

  ④ Lambda和Method Reference效率其实很贴近,又是一起在Java8推出的,底层实现应该是一样的,在效率上比起反射好很多。

  上个版本中,我使用的Method Reference,下个版本还会继续使用Method Reference,因为接口方式和内部类一致,如果碰到某些对性能要求非常极致的使用场景,可以在使用时以内部类的方式替代Method Reference而不需要改变工具类的代码。

原文地址https://www.cnblogs.com/supalle/p/11249227.html

网友评论

作者关闭了评论