Android程序性能设计最佳实践

浏览数：12 / 时间：2015年06月11日

Android应用应该要很快，更精确的说应该是要有效率。那就是说移动设备环境中有限的计算能力和数据存储，很小的屏幕，有限的电池寿命中要更有效率。

这篇博客我就会向你展示为性能而设计的最佳实践。

1. 避免创建对象

对象的创建在android中开销要比在java中大的多。尽量去避免创建一个对象，越多的对象意味着越多的垃圾回收，越多的垃圾回收意味着用户会觉得有点“小卡”。

一般的说，尽可能避免创建短暂的临时变量，更少的对象创建意味着更少的垃圾回收，将会提升用户体验。如果能创建一个“池”来管理对象的话，那是最好的了。

2. 将阻塞操作从UI线程中剥离出来

使用AsyncTask, Thread, IntentService,或者简单的后台Service去做大开销的操作。使用Loaders去简化管理很长时间加载数据的状态就像一个指针。如果一个操作需要消耗时间和资源，那就放到另外的进程中异步进行，这样你的程序就能够继续响应并且用户也可以进行操作。

3. 使用Native方法

同样一个Java循环，C/C++代码可以快10到100倍。

4. 实现优于接口

假设你有一个HashMap对象，你可以使用通用的Map来声明这个HashMap:

Map myMap1 = new HashMap();

HashMap myMap2 = new HashMap();

哪一种更好？

传统的观点认为你应该使用Map，因为它允许你更改为只要实现了Map接口的底层实现。传统观点对于常规编程是正确的，但是对于嵌入式系统来说就不是那么好了。调用一个接口引用的方法相对于调用一个固定实现的引用要多花费2倍的时间。

如果你HashMap能处理你要做的事情，那么使用Map来申明就没有一点价值了。让IDE帮你重构你的代码，就算你对代码还没有头绪，使用Map也是没什么价值的。（当然，公共的API可能有不同：一个好的API肯定胜过小的性能问题）

5. 静态方法更好

如果你的方法不需要访问一个对象的变量，那么将你的方法改为静态的。调用起来会快很多，因为它将不需要经过virtual method table。这也是一个很好的实践，因为你可以告诉方法签名在调用方法的时候不会更改对象的状态。

6. 避免使用内部的Getters/Setters

在像C++这种语言中，经常会见到getters（比如 i=getCount()）来代替直接访问变量（i=mCount）。这是一个非常好的习惯，因为编译器会使用内联访问，而且如果你相对字段做约束或者进行调试的时候，你可以随时的修改代码。

在Android中，这是一个不好的想法。虚拟函数的调用开销很大，远远超过了变量的访问。如果是一个类，你应该直接访问变量，如果是一个公共接口，还是尽量遵循面向对象编程的实践使用Getters/Setters。

7. 常量声明Final

考虑下面的变量声明：

static int intVal = 42;
static String strVal = "Hello, world!";

编译器生成一个类的构造方法，叫<clinit>，它会在类第一次使用的时候触发。方法会将42保存到intVal，从String表里获取一个引用给strVal。当这些值被引用后，他们访问时就能够去查找了。

我们可以使用final关键字来提升性能：

static final int intVal = 42;
static final String strVal = "Hello, world!";

类文件不再需要<clinit>方法了，因为常量转为了虚拟机进行处理。代码访问intVal的时候直接就能拿到42，访问strVal的时候开销也会相对更小。

声明类或者方法final并不能获得性能上的好处，不够能够有其他的效果。比如，如果不想让子类重写getter方法，那么就可以声明final。

你也可以本地变量final。然而这不会有任何的性能效益。对于本地变量，使用final仅仅能让代码语义更加清晰（或者你可以让匿名类访问到这个变量）。

8. 小心使用增强的for循环

增强行的for循环（也可以说是for-each循环）可以使用在任何实现了iterable接口的集合上。对于这些对象，iterator会调用hasNext()和next()接口来创建，对于ArrayList，你最好避开这种方式，不过对于其他种类的集合，增强型for循环和显式的使用迭代循环相差无几。

下面代码展示了增强型的for循环：

public class Foo {
    int mSplat;
    static Foo mArray[] = new Foo[27];

    public static void zero() {
        int sum = 0;
        for (int i = 0; i < mArray.length; i++) {
            sum += mArray[i].mSplat;
        }
    }

    public static void one() {
        int sum = 0;
        Foo[] localArray = mArray;
        int len = localArray.length;

        for (int i = 0; i < len; i++) {
            sum += localArray[i].mSplat;
        }
    }

    public static void two() {
        int sum = 0;
        for (Foo a: mArray) {
            sum += a.mSplat;
        }
    }
}

zero()检索static变量两次，而且每次循环都会获取数组的长度。

one()将所有东西就放到了临时变量中，避免了查找。

two()使用1.5版本java的增强型for循环，由编译器来生成代码，复制数组引用和数组长度到本地变量，产生一个好的访问数组方案，它会产生一个额外的本地加载存储（保存a这个对象），它会比one()要慢一点点。

总结就是：增强型for循环有更好的语义和代码结构，但是要谨慎使用它，因为有可能会有额外的创建对象开销。

9. 避免Enums

枚举非常的方便，但是不幸的是他的速度的大小都是让人痛苦的。比如说：

public class Foo {
   public enum Shrubbery { GROUND, CRAWLING, HANGING }
}

会编译成900byte的.class文件 (Foo$Shrubbery.class)。当第一次使用，类会调用初始化函数<init>来对每一个枚举值创建对象。每一个对象都有自己的静态变量，而且全部都保存在一个数组中（一个叫"$VALUES"的静态变量）。这么多的代码，仅仅只是为了三个整数。

下面这句代码:

Shrubbery shrub = Shrubbery.GROUND;

一个静态变量的查找。如果"GROUND"是一个静态的int常量，编译器会把它当做一个已知常量并且使用内联。

从另一个方面说，你当然会从枚举类型中获得很多好用的API和编译时的检查。所以，通常需要这样来权衡：你应该在所有公共API的地方尽量使用枚举类型，不过在性能重要的时候，尽量避免使用。

在一些环境中，通过ordinal()方法来获取enum的数值很有用，比如：

for (int n = 0; n < list.size(); n++) {
    if (list.items[n].e == MyEnum.VAL_X)
       // do stuff 1
    else if (list.items[n].e == MyEnum.VAL_Y)
       // do stuff 2
}

然后:

int valX = MyEnum.VAL_X.ordinal();
int valY = MyEnum.VAL_Y.ordinal();
int count = list.size();
MyItem items = list.items();

for (int  n = 0; n < count; n++)
{
     int  valItem = items[n].e.ordinal();

     if (valItem == valX)
       // do stuff 1
     else if (valItem == valY)
       // do stuff 2
}

在一些案例中，这将会更快，尽管这没有保证。

10. 对内部类使用Package访问权限

考虑一下下面的类定义：

public class Foo {
    private int mValue;

    public void run() {
        Inner in = new Inner();
        mValue = 27;
        in.stuff();
    }


    private void doStuff(int value) {
        System.out.println("Value is " + value);
    }

    private class Inner {
        void stuff() {
            Foo.this.doStuff(Foo.this.mValue);
        }
    }
}

关键的事事：我们定义了一个内部类(Foo$Inner)直接访问了外部类的private方法和private实例。这是合法的，而且代码打印出了我们期望的"Value is 27"。

问题是Foo$Inner在技术上来说，是一个完全独立的类。它来直接访问Foo的私有成员是违法的。为了弥补这个问题，编译器会生成下面的方法：

/*package*/ static int Foo.access$100(Foo foo) {
    return foo.mValue;
}
/*package*/ static void Foo.access$200(Foo foo, int value) {
    foo.doStuff(value);
}

内部类代码会调用方法来访问外部的mValue或者调用外部的doStuff方法。这意味着上面的代码真正的情况是，你是通过的访问器访问而不是通过直接访问的代码。之前我们就讨论过了使用访问器要比直接访问变量更慢，所以这就是一个特定的语言习惯形成的一种"隐形"的性能影响。

我们可以通过声明package访问空间而不是private访问空间来避免这个问题。这将会运行的更快，而且避免了生成方法产生的开销。（不幸的是，这可能让在同一个package下的其他包能够直接访问这个变量，这违反了面向对象的设计思想。再次说明一下，如果你要设计一个公共的API，你就要仔细考虑一下了。）

11. 避免Float

在奔腾CPU发布之前，几乎所有的游戏开发者都会尽量使用整数运算。奔腾CPU将浮点数协处理器设置成了内置功能。通过交叉整数和浮点操作使游戏比以前纯整数运算的时候要快。桌面程序现在常见的做法是随意使用float。

不幸的是，嵌入式处理器通常没有浮点支持，所以所有的float和double操作开销都很大。一些基本的浮点操作可以在一毫秒的顺序完成。

同样,即使是整数,一些芯片支持乘法,但缺乏除法。在这种情况下,在软件执行整数除法和模量操作时,想想如果你设计一个哈希表或做大量的数学。

12. 一些简单的性能数字

为了说明我们的一些想法,我们对一些基本的行为列出了近似运行时间。请注意,这些值不应被视为绝对数字:他们是CPU和时钟时间的组合,并且对于系统的改进将变化。值得注意的是这些值是相对于彼此——例如,添加一个成员变量目前需要的时间大约是添加一个本地变量的四倍。

Action	Time
Add a local variable	1
Add a member variable	4
Call String.length()	5
Call empty static native method	5
Call empty static method	12
Call empty virtual method	12.5
Call empty interface method	15
Call Iterator:next() on a HashMap	165
Call put() on a HashMap	600
Inflate 1 View from XML	22,000
Inflate 1 LinearLayout containing 1 TextView	25,000
Inflate 1 LinearLayout containing 6 View objects	100,000
Inflate 1 LinearLayout containing 6 TextView objects	135,000
Launch an empty activity	3,000,000