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

上一篇里对几种书写方式进行了简单的测试，得出了一些初步的结论。这次简单了解Lambda原理后，对测试做了一些调整，发现得到不一样的结果，而这个调整，明显更契合实际开发的场景。

暂时还没有亲自去验证，主要是从博客中了解的Lambda原理，引起一些启发，对测试代码进行了一些改善。

在此感谢这篇博客的作者：https://www.cnblogs.com/UncleWang001/p/10020611.html - lambda表达式底层处理机制

调整后的代码：

  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<SyntaxPKTest.Man> 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         Supplier<Man> supplier = new Supplier<Man>() {
 74             @Override
 75             public Man get() {
 76                 return new Man();
 77             }
 78         };
 79         for (int i = 0; i < SIZE; i++) {
 80             supplier.get();
 81
 82         }
 83
 84         return System.currentTimeMillis() - start;
 85     }
 86
 87     /**
 88      * 使用Lambda调用 new Man();
 89      *
 90      * @return 运行耗时
 91      */
 92     public static long runWithLambda() {
 93         long start = System.currentTimeMillis();
 94
 95         Supplier<Man> supplier = () -> new Man();
 96
 97         for (int i = 0; i < SIZE; i++) {
 98             supplier.get();
 99         }
100
101         return System.currentTimeMillis() - start;
102     }
103
104
105     /**
106      * 使用 MethodReference
107      *
108      * @return 运行耗时
109      */
110     public static long runWithMethodReference() {
111         long start = System.currentTimeMillis();
112
113         Supplier<Man> supplier = Man::new;
114
115         for (int i = 0; i < SIZE; i++) {
116             supplier.get();
117         }
118
119         return System.currentTimeMillis() - start;
120     }
121
122     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
123
124         // 测试前调用一下，加载Man字节码，尽量公平
125         SyntaxPKTest.Man man1 = new SyntaxPKTest.Man();
126         SyntaxPKTest.Man man2 = new SyntaxPKTest.Man("张三", 20);
127
128         System.out.println("测试环境：CPU核心数 - " + Runtime.getRuntime().availableProcessors());
129
130         System.out.println();
131
132         // 这里的话对比再次调用的时间
133         System.out.println("首次使用 new Man()            耗时：" + runWithNewConstructor());
134         System.err.println("再次使用 new Man()            耗时：" + runWithNewConstructor());
135         System.out.println("首次使用反射                   耗时：" + runWithReflex());
136         System.err.println("再次使用反射                   耗时：" + runWithReflex());
137         System.out.println("首次使用内部类调用 new Man()    耗时：" + runWithSubClass());
138         System.err.println("再次使用内部类调用 new Man()    耗时：" + runWithSubClass());
139         System.out.println("首次使用Lambda调用 new Man()   耗时：" + runWithLambda());
140         System.err.println("再次使用Lambda调用 new Man()   耗时：" + runWithLambda());
141         System.out.println("首次使用 MethodReference      耗时：" + runWithMethodReference());
142         System.err.println("再次使用 MethodReference      耗时：" + runWithMethodReference());
143
144
145     }
146
147 }

这次调整，仅仅只是把内部类、Lambda、Method Reference 放到循环外边，更符合我们常用的情形。

测试结果较之上一篇真的有很大的变化。

 1 首次使用 new Man()            耗时：4
 2 再次使用 new Man()            耗时：1
 3 首次使用反射                   耗时：237
 4 再次使用反射                   耗时：251
 5 首次使用内部类调用 new Man()    耗时：5
 6 再次使用内部类调用 new Man()    耗时：2
 7 首次使用Lambda调用 new Man()   耗时：41
 8 再次使用Lambda调用 new Man()   耗时：3
 9 首次使用 MethodReference      耗时：4
10 再次使用 MethodReference      耗时：1

 1 首次使用 new Man()            耗时：3
 2 再次使用 new Man()            耗时：2
 3 首次使用反射                   耗时：240
 4 再次使用反射                   耗时：256
 5 首次使用内部类调用 new Man()    耗时：5
 6 再次使用内部类调用 new Man()    耗时：3
 7 首次使用Lambda调用 new Man()   耗时：43
 8 再次使用Lambda调用 new Man()   耗时：4
 9 首次使用 MethodReference      耗时：4
10 再次使用 MethodReference      耗时：1

首次使用 new Man()            耗时：3
再次使用 new Man()            耗时：2
首次使用反射                   耗时：238
再次使用反射                   耗时：251
首次使用内部类调用 new Man()    耗时：5
再次使用内部类调用 new Man()    耗时：1
首次使用Lambda调用 new Man()   耗时：39
再次使用Lambda调用 new Man()   耗时：5
首次使用 MethodReference      耗时：3
再次使用 MethodReference      耗时：2

可以看到Lambda和Method Reference同样耗时非常小，主要是在使用其创建了Supplier<Man>接口的实现实例后，本质上就和内部类创建出来的对象没有差别，因此在性能表现上相差不大。

结论：

　　如果既要保持灵活简洁又追求极致的性能时，那么使用在Lambda或者Method Reference时，尽量不要写在循环内部。