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

2017年6月13日

前言

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

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

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

设计实验

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

1. 一亿次循环运算空跑的耗时情况；
2. if语句条件表达式为简单运算的情况的耗时情况；
3. if语句条件表达式为局部boolean且值为true；
4. if语句条件表达式为局部boolean且值为false;
5. if语句条件表达式为局部final boolean且值为false；
6. if语句条件表达式为全局boolean且值为false；
7. if语句条件表达式为全局final boolean且值为false;
8. if语句条件表达式为另一个类对象中的实例变量boolean且值为false；
9. if语句条件表达式为另一个类对象中的静态变量boolean且值为true；
10. if语句条件表达式为另一个类对象中的静态变量boolean且值为false；
11. if语句条件表达式为另一个类对象中的静态final布尔变量且值为true；
12. if语句条件表达式为另一个类对象中的静态final布尔变量且值为false；
13. if语句条件表达式为静态final变量boolean且值为false；
14. if语句条件表达式为静态变量boolean且值为false；

实验环境

　　操作系统：Android 5.1

　　设备系统：4K智能电视

　　处理器：Hi3751v620

　　内存：2GB

代码设计

MainActivity.java 主要代码

     private final String TAG = "chorm";

     private final int chorm = 100000000;// 1亿
     private boolean fieldBool;
     private final boolean fieldBool2 = false;
     private static boolean B3 = false;
     private final static boolean B4 = false;

     private long getTime() {
         return SystemClock.uptimeMillis();
     }

     public void click(View v) {
         int counter;

         Log.i(TAG, "- Prebuilt -");
         counter = chorm;
         long start = getTime();
         do {
             counter--;
         } while (counter > 0);
         long end = getTime();

         Log.i(TAG, " - Demo begin -");
         // 1. 一亿次循环运算空跑的耗时情况；
         counter = chorm;
         start = getTime();
         do {
             counter--;
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "1:Time spent:" + (end - start) + "ms");

         // 2. if语句条件表达式为简单运算的情况的耗时情况；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if ((9 + 17) == 8) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "2:Time spent:" + (end - start) + "ms");

         // 3. if语句条件表达式为局部boolean且值为true；
         counter = chorm;
         boolean localBool = true;
         start = getTime();
         do {
             counter--;
             if (localBool) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "3:Time spent:" + (end - start) + "ms");

         // 4. if语句条件表达式为局部boolean且值为false;
         counter = chorm;
         localBool = false;
         start = getTime();
         do {
             counter--;
             if (localBool) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "4:Time spent:" + (end - start) + "ms");

         // 5. if语句条件表达式为局部final boolean且值为false；
         counter = chorm;
         final boolean localBool2 = false;
         start = getTime();
         do {
             counter--;
             if (localBool2) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "5:Time spent:" + (end - start) + "ms");

         // 6. if语句条件表达式为全局boolean且值为false；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (fieldBool) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "6:Time spent:" + (end - start) + "ms");

         // 7. if语句条件表达式为全局final boolean且值为false;
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (fieldBool2) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "7:Time spent:" + (end - start) + "ms");

         // 8. if语句条件表达式为另一个类对象中的实例变量boolean且值为false；
         counter = chorm;
         AnotherClass ac = new AnotherClass();
         start = getTime();
         do {
             counter--;
             if (ac.bool) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "8:Time spent:" + (end - start) + "ms");

         // 9. if语句条件表达式为另一个类对象中的静态变量boolean且值为true；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (AnotherClass.BOOL) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "9:Time spent:" + (end - start) + "ms");

         // 10. if语句条件表达式为另一个类对象中的静态变量boolean且值为false；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (AnotherClass.BOOL2) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "10:Time spent:" + (end - start) + "ms");

         // 11. if语句条件表达式为另一个类对象中的静态final变量boolean且值为true；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (AnotherClass.BOOL3) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "11:Time spent:" + (end - start) + "ms");

         // 12. if语句条件表达式为另一个类对象中的静态final变量boolean且值为false；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (AnotherClass.BOOL4) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "12:Time spent:" + (end - start) + "ms");

         // 13. if语句条件表达式为静态final变量boolean且值为false；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (B4) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "13:Time spent:" + (end - start) + "ms");

         // 14. if语句条件表达式为静态变量boolean且值为false；
         counter = chorm;
         start = getTime();
         do {
             counter--;
             if (B3) {

             }
         } while (counter > 0);
         end = getTime();
         Log.d(TAG, "14:Time spent:" + (end - start) + "ms");

         Log.v(TAG, " - Demo end -");
     }

AnotherClass.java

 public class AnotherClass {
     public static boolean BOOL = true;
     public static boolean BOOL2 = false;
     public static final boolean BOOL3 = true;
     public static final boolean BOOL4 = false;
     public boolean bool;
 }

实验结果

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

　　　　第一组：开机后在首页

　　　　第二组：打开了很多应用以后

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

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

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

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

　　　　　　　　　　　　　　　　　　　　　　　单位：毫秒（ms）

序号	第一组	第二组	第三组	第四组	第五组	第六组	耗时均值
1	347						345.5
2	347	359	347	344		345	347.67
3	346	348	346	345		344	345.5
4	346	347	345	344		344	345
5	347	346	346	344	344	345	345.17
6	347	346	345	345	344	344	345.17
7	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.33
11							344.5
12							347.83
13							346
14							345.17

结论

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

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