简单探究Android平台下' if ' 语句条件判断耗时状况

时间 2019-11-16

标签简单探究 android 平台语句条件判断耗时状况栏目 Android 繁體版

原文原文链接

2017年6月13日java

前言

　　前几日在改Bug时看到好多调试时用的日志语句都被一个日志开关控制着它的执行权。形如：测试

1 if(Constants.LOG_TAG){
2     Log.d(TAG, "Initialize finish! index:" + idx);
3 }

又为了方便往后遇到问题时的分析，还要加上不少相似的日志语句。这时忽然很好奇“大量的”条件判断语句须要多消耗多少系统资源，以及不一样的条件表达式占用系统资源的差别状况。为此，特地设计了一个简单的小实验，经过取多组不一样环境下这几种情形的耗时均值做为考量依据。ui

设计实验

　　对指定的条件语句进行一亿次的运算，计算运算先后的时间差做为结果。spa

一亿次循环运算空跑的耗时状况；
if语句条件表达式为简单运算的状况的耗时状况；
if语句条件表达式为局部boolean且值为true；
if语句条件表达式为局部boolean且值为false;
if语句条件表达式为局部final boolean且值为false；
if语句条件表达式为全局boolean且值为false；
if语句条件表达式为全局final boolean且值为false;
if语句条件表达式为另外一个类对象中的实例变量boolean且值为false；
if语句条件表达式为另外一个类对象中的静态变量boolean且值为true；
if语句条件表达式为另外一个类对象中的静态变量boolean且值为false；
if语句条件表达式为另外一个类对象中的静态final布尔变量且值为true；
if语句条件表达式为另外一个类对象中的静态final布尔变量且值为false；
if语句条件表达式为静态final变量boolean且值为false；
if语句条件表达式为静态变量boolean且值为false；

实验环境

　　操做系统：Android 5.1操作系统

　　设备系统：4K智能电视设计

　　处理器：Hi3751v620调试

　　内存：2GB日志

代码设计

MainActivity.java 主要代码code

  1     private final String TAG = "chorm";
  2 
  3     private final int chorm = 100000000;// 1亿
  4     private boolean fieldBool;
  5     private final boolean fieldBool2 = false;
  6     private static boolean B3 = false;
  7     private final static boolean B4 = false;
  8 
  9     private long getTime() {
 10         return SystemClock.uptimeMillis();
 11     }
 12 
 13     public void click(View v) {
 14         int counter;
 15 
 16         Log.i(TAG, "- Prebuilt -");
 17         counter = chorm;
 18         long start = getTime();
 19         do {
 20             counter--;
 21         } while (counter > 0);
 22         long end = getTime();
 23 
 24         Log.i(TAG, " - Demo begin -");
 25         // 1. 一亿次循环运算空跑的耗时状况；
 26         counter = chorm;
 27         start = getTime();
 28         do {
 29             counter--;
 30         } while (counter > 0);
 31         end = getTime();
 32         Log.d(TAG, "1:Time spent:" + (end - start) + "ms");
 33 
 34         // 2. if语句条件表达式为简单运算的状况的耗时状况；
 35         counter = chorm;
 36         start = getTime();
 37         do {
 38             counter--;
 39             if ((9 + 17) == 8) {
 40 
 41             }
 42         } while (counter > 0);
 43         end = getTime();
 44         Log.d(TAG, "2:Time spent:" + (end - start) + "ms");
 45 
 46         // 3. if语句条件表达式为局部boolean且值为true；
 47         counter = chorm;
 48         boolean localBool = true;
 49         start = getTime();
 50         do {
 51             counter--;
 52             if (localBool) {
 53 
 54             }
 55         } while (counter > 0);
 56         end = getTime();
 57         Log.d(TAG, "3:Time spent:" + (end - start) + "ms");
 58 
 59         // 4. if语句条件表达式为局部boolean且值为false;
 60         counter = chorm;
 61         localBool = false;
 62         start = getTime();
 63         do {
 64             counter--;
 65             if (localBool) {
 66 
 67             }
 68         } while (counter > 0);
 69         end = getTime();
 70         Log.d(TAG, "4:Time spent:" + (end - start) + "ms");
 71 
 72         // 5. if语句条件表达式为局部final boolean且值为false；
 73         counter = chorm;
 74         final boolean localBool2 = false;
 75         start = getTime();
 76         do {
 77             counter--;
 78             if (localBool2) {
 79 
 80             }
 81         } while (counter > 0);
 82         end = getTime();
 83         Log.d(TAG, "5:Time spent:" + (end - start) + "ms");
 84 
 85         // 6. if语句条件表达式为全局boolean且值为false；
 86         counter = chorm;
 87         start = getTime();
 88         do {
 89             counter--;
 90             if (fieldBool) {
 91 
 92             }
 93         } while (counter > 0);
 94         end = getTime();
 95         Log.d(TAG, "6:Time spent:" + (end - start) + "ms");
 96 
 97         // 7. if语句条件表达式为全局final boolean且值为false;
 98         counter = chorm;
 99         start = getTime();
100         do {
101             counter--;
102             if (fieldBool2) {
103 
104             }
105         } while (counter > 0);
106         end = getTime();
107         Log.d(TAG, "7:Time spent:" + (end - start) + "ms");
108 
109         // 8. if语句条件表达式为另外一个类对象中的实例变量boolean且值为false；
110         counter = chorm;
111         AnotherClass ac = new AnotherClass();
112         start = getTime();
113         do {
114             counter--;
115             if (ac.bool) {
116 
117             }
118         } while (counter > 0);
119         end = getTime();
120         Log.d(TAG, "8:Time spent:" + (end - start) + "ms");
121 
122         // 9. if语句条件表达式为另外一个类对象中的静态变量boolean且值为true；
123         counter = chorm;
124         start = getTime();
125         do {
126             counter--;
127             if (AnotherClass.BOOL) {
128 
129             }
130         } while (counter > 0);
131         end = getTime();
132         Log.d(TAG, "9:Time spent:" + (end - start) + "ms");
133 
134         // 10. if语句条件表达式为另外一个类对象中的静态变量boolean且值为false；
135         counter = chorm;
136         start = getTime();
137         do {
138             counter--;
139             if (AnotherClass.BOOL2) {
140 
141             }
142         } while (counter > 0);
143         end = getTime();
144         Log.d(TAG, "10:Time spent:" + (end - start) + "ms");
145 
146         // 11. if语句条件表达式为另外一个类对象中的静态final变量boolean且值为true；
147         counter = chorm;
148         start = getTime();
149         do {
150             counter--;
151             if (AnotherClass.BOOL3) {
152 
153             }
154         } while (counter > 0);
155         end = getTime();
156         Log.d(TAG, "11:Time spent:" + (end - start) + "ms");
157 
158         // 12. if语句条件表达式为另外一个类对象中的静态final变量boolean且值为false；
159         counter = chorm;
160         start = getTime();
161         do {
162             counter--;
163             if (AnotherClass.BOOL4) {
164 
165             }
166         } while (counter > 0);
167         end = getTime();
168         Log.d(TAG, "12:Time spent:" + (end - start) + "ms");
169         
170         // 13. if语句条件表达式为静态final变量boolean且值为false；
171         counter = chorm;
172         start = getTime();
173         do {
174             counter--;
175             if (B4) {
176                 
177             }
178         } while (counter > 0);
179         end = getTime();
180         Log.d(TAG, "13:Time spent:" + (end - start) + "ms");
181         
182         // 14. if语句条件表达式为静态变量boolean且值为false；
183         counter = chorm;
184         start = getTime();
185         do {
186             counter--;
187             if (B3) {
188                 
189             }
190         } while (counter > 0);
191         end = getTime();
192         Log.d(TAG, "14:Time spent:" + (end - start) + "ms");
193 
194         Log.v(TAG, " - Demo end -");
195     }

AnotherClass.javaorm

1 public class AnotherClass {
2     public static boolean BOOL = true;
3     public static boolean BOOL2 = false;
4     public static final boolean BOOL3 = true;
5     public static final boolean BOOL4 = false;
6     public boolean bool;
7 }

实验结果

　　共进行了五个不一样环境下的测试实验。

　　　　第一组：开机后在首页

　　　　第二组：打开了不少应用之后

　　　　第三组：播放数字电视节目时启动测试应用。

　　　　第四组：播放一段4K视频时启动测试应用。

　　　　第五组：在首页启动测试应用。

　　　　第六组：在首页启动测试应用。

　　　　　　　　　　　　　　　　　　　　　　　单位：毫秒（ms）

序号	第一组	第二组	第三组	第四组	第五组	第六组	耗时均值
1	347	344	348	346	344	344	345.5
2	347	359	347	344	344	345	347.67
3	346	348	346	345	344	344	345.5
4	346	347	345	344	344	344	345
5	347	346	346	344	344	345	345.17
6	347	346	345	345	344	344	345.17
7	346	346	346	344	344	344	345
8	347	346	345	344	344	345	345.17
9	2292	2277	2279	2268	2265	2264	2274.17
10	1410	1411	1408	1411	1411	1411	1410.33
11	345	345	344	345	344	344	344.5
12	345	345	344	346	363	344	347.83
13	346	345	350	345	345	345	346
14	344	345	350	344	344	344	345.17

结论

对于if语句条件表达式的耗时应以条件结果为false的为准。
大多数状况下条件判断所耗时间至关。
当条件被判断为true时（对比三、4），即时后面的方法体是空的，也须要更多的时间来执行，对比九、10的结果更明显。
非必须条件下不要在条件判断语句处做运算（结果2），尽量地将运算过程放在编译时来执行。
变量是否被final修饰彷佛对结果没有什么影响（四、5与六、7），事实上这个结果让我也很迷惑。不排除是个人测试环境与测试方法的问题。
变量定义在哪个对象对结果没有什么影响（结果六、结果8 ）
对于另外一个类对象中的静态变量，所花费的时间相较于其它状况长不少（结果九、结果10）。尽可能不要使用其它类对象中的非final静态变量。

　　我相信没什么应用的调试日志数量能达到1亿条或者更多。即便是1410.33毫秒，分红1亿份，它的时间也是微不足道的，而且市面上移动设备处理器一般都比我手里这块要好。所以，实际结论是：你想怎样用就怎样用。固然，日志打印的耗时状况就不在咱们的讨论范围以内了。