深入优化Android应用性能

5星 · 超过95%的资源需积分: 12 171 浏览量更新于2024-07-27 2 收藏 2.63MB PDF 举报

"Pro Android Apps Performance Optimization - 这本书是关于Android应用性能优化的高级指南，适合面试准备，探讨编程技巧和提升应用效率" 在移动开发领域，尤其是Android平台，优化应用性能是至关重要的，因为这直接影响到用户体验和设备资源的消耗。《Pro Android Apps Performance Optimization》这本书深入探讨了如何最大化提升Android应用的性能，使其运行更流畅、更高效。书中涵盖了各种技术细节和策略，旨在帮助开发者们构建出高质量的应用。 1. **内存管理**：书中有专门章节讨论Android应用的内存优化，包括如何有效地分配和回收内存，避免内存泄漏，以及使用内存分析工具来检测和解决问题。理解对象生命周期和引用类型（强引用、软引用、弱引用、虚引用）对于避免内存泄漏至关重要。 2. **UI性能优化**：书中会讲解如何减少UI更新对主线程的影响，如使用异步加载、多线程处理和UI优化工具，以及如何利用硬件加速功能提高绘制效率。此外，还会涉及到布局优化，如减少嵌套和使用更轻量级的视图组件。 3. **代码性能**：书里可能会介绍代码优化技巧，如避免冗余计算，合理使用数据结构和算法，以及如何进行高效的资源加载。理解和运用Java编程最佳实践，如避免过度使用反射和枚举，也能显著提升代码执行效率。 4. **电池寿命和资源消耗**：性能优化不仅限于CPU和内存，还包括电池使用和网络数据的节省。书中的内容可能包括优化后台服务，减少不必要的唤醒，以及智能地使用同步策略来减少电量消耗。 5. **性能分析和调试**：作者会介绍一系列工具，如Android Studio的Profiler，用于性能分析和调试，帮助开发者定位和修复性能瓶颈。理解这些工具的使用方法是持续优化应用的关键。 6. **程序启动时间和响应速度**：快速的启动时间和高响应性是用户满意度的重要因素。书里可能涉及如何减少启动时间，通过预加载、懒加载等技术优化应用启动过程。 7. **GPU渲染和动画优化**：Android应用中的图形和动画处理也会影响性能。书中可能涵盖如何利用硬件加速，优化OpenGL ES代码，以及如何创建流畅的动画序列，确保视觉效果与性能并重。 8. **测试和基准**：性能优化是一个持续的过程，需要通过系统化的测试和基准测试来验证优化的效果。书里会介绍如何设置性能测试场景，以及如何分析和解读测试结果。《Pro Android Apps Performance Optimization》是开发者深入学习Android性能优化的宝贵资源，无论是在面试中展示专业技能，还是在实际开发中提升应用质量，都能从中获益良多。通过掌握书中的技巧和最佳实践，开发者可以确保他们的应用在竞争激烈的市场中脱颖而出。

CHAPTER 1: Optimizing Java Code

002564: 7110 3d00 0000 |0006: invoke-static {v0},

Lcom/apress/proandroid/Fibonacci;.computeRecursively:(I)J

00256a: 0b00 |0009: move-result-wide v0

00256c: 9102 0402 |000a: sub-int v2, v4, v2

002570: 7110 3d00 0200 |000c: invoke-static {v2},

Lcom/apress/proandroid/Fibonacci;.computeRecursively:(I)J

002576: 0b02 |000f: move-result-wide v2

002578: bb20 |0010: add-long/2addr v0, v2

00257a: 1000 |0011: return-wide v0

00257c: 8140 |0012: int-to-long v0, v4

00257e: 28fe |0013: goto 0011 // -0002

The first number on each line specifies the absolute position of the code within the file.

Except on the very first line (which shows the method name), it is then followed by one

or more 16-bit bytecode units, followed by the position of the code within the method

itself (relative position, or label), the opcode mnemonic and finally the opcode’s

parameter(s). For example, the two bytecode units 3724 1100 at address 0x00255a

translate to “if-le v4, v2, 0012 // +0011”, which basically means “if content of virtual

by skipping 17 bytecode units” (17

equals 11

). The term “virtual register” refers to the

fact that these are not actual hardware registers but instead the registers used by the

Dalvik virtual machine.

Typically, you would not need to look at your application’s bytecode. This is especially

true with Android 2.2 (codename Froyo) and later versions since a Just-In-Time (JIT)

compiler was introduced in Android 2.2. The Dalvik JIT compiler compiles the Dalvik

bytecode into native code, which can execute significantly faster. A JIT compiler

(sometimes referred to simply as a JIT) improves performance dramatically because:

 Native code is directly executed by the CPU without having to be

interpreted by a virtual machine.

 Native code can be optimized for a specific architecture.

Benchmarks done by Google showed code executes 2 to 5 times faster with

Android 2.2 than Android 2.1. While the results may vary depending on what

your code does, you can expect a significant increase in speed when using

Android 2.2 and later versions.

The absence of a JIT compiler in Android 2.1 and earlier versions may affect

your optimization strategy significantly. If you intend to target devices running

Android 1.5 (codename Cupcake), 1.6 (codename Donut), or 2.1 (codename

Éclair), most likely you will need to review more carefully what you want or

need to provide in your application. Moreover, devices running these earlier

Android versions are older devices, which are less powerful than newer ones.

While the market share of Android 2.1 and earlier devices is shrinking, they still

represent about 12% as of December 2011). Possible strategies are:

 Don’t optimize at all. Your application could be quite slow on these

older devices.

CHAPTER 1: Optimizing Java Code

 Require minimum API level 8 in your application, which can then be

installed only on Android 2.2 or later versions.

 Optimize for older devices to offer a good user experience even

when no JIT compiler is present. This could mean disabling features

that are too CPU-heavy.

TIP: Use android:vmSafeMode in your application’s manifest to enable or disable the JIT

compiler. It is enabled by default (if it is available on the platform). This attribute was introduced

in Android 2.2.

Now it is time to run the code on an actual platform and see how it performs. If you are

familiar with recursion and the Fibonacci series, you might guess that it is going to be

slow. And you would be right. On a Samsung Galaxy Tab 10.1, computing the thirtieth

Fibonacci number takes about 370 milliseconds. With the JIT compiler disabled, it takes

about 440 milliseconds. If you decide to include that function in a Calculator application,

users will become frustrated because the results cannot be computed “immediately.”

From a user’s point of view, results appear instantaneous if they can be computed in

100 milliseconds or less. Such a response time guarantees a very good user experience,

so this is what we are going to target.

Optimizing Fibonacci

The first optimization we are going to perform eliminates a method call, as

shown in Listing 1–3. As this implementation is recursive, removing a single

call in the method dramatically reduces the total number of calls. For example,

computeRecursively(30) generated 2,692,537 calls while

computeRecursivelyWithLoop(30) generated “only” 1,346,269. However, the

performance of this method is still not acceptable considering the response-

time criteria defined above, 100 milliseconds or less, as

computeRecursivelyWithLoop(30) takes about 270 milliseconds to complete.

Listing 1–3. Optimized Recursive Implementation of Fibonacci Series

public class Fibonacci {

public static long computeRecursivelyWithLoop (int n)

{

if (n > 1) {

long result = 1;

do {

result += computeRecursivelyWithLoop(n-2);

n--;

} while (n > 1);

return result;

}

return n;

}

CHAPTER 1: Optimizing Java Code

NOTE: This is not a true tail-recursion optimization.

From Recursive To Iterative

For the second optimization, we switch from a recursive implementation to an iterative

one. Recursive algorithms often have a bad reputation with developers, especially on

embedded systems without much memory, because they tend to consume a lot of stack

space and, as we just saw, can generate too many method calls. Even when

performance is acceptable, a recursive algorithm can cause a stack overflow and crash

an application. An iterative implementation is therefore often preferred whenever

possible. Listing 1–4 shows what is considered a textbook iterative implementation of

the Fibonacci series.

Listing 1–4. Iterative Implementation of Fibonacci Series

public class Fibonacci {

public static long computeIteratively (int n)

{

if (n > 1) {

long a = 0, b = 1;

do {

long tmp = b;

b += a;

a = tmp;

} while (--n > 1);

return b;

}

return n;

}

Because the n

term of the Fibonacci series is simply the sum of the two previous

terms, a simple loop can do the job. Compared to the recursive algorithms, the

complexity of this iterative algorithm is also greatly reduced because it is linear.

Consequently, its performance is also much better, and computeIteratively(30) takes

less than 1 millisecond to complete. Because of its linear nature, you can use such an

algorithm to compute terms beyond the 30

. For example, computeIteratively(50000)

takes only 2 milliseconds to return a result and, by extrapolation, you could guess

computeIteratively(500000) would take between 20 and 30 milliseconds to complete.

While such performance is more than acceptable, it is possible to to achieve even faster

results with a slightly modified version of the same algorithm, as showed in Listing 1–5.

This new version computes two terms per iteration, and the total number of iterations is

halved. Because the number of iterations in the original iterative algorithm could be odd,

the initial values for a and b are modified accordingly: the series starts with a=0 and b=1

when n is odd, and it starts with a=1 and b=1 (Fib(2)=1) when n is even.

CHAPTER 1: Optimizing Java Code

Listing 1–6. BigInteger Version of Fibonacci.computeIterativelyFaster

public class Fibonacci {

public static BigInteger computeIterativelyFasterUsingBigInteger (int n)

{

if (n > 1) {

BigInteger a, b = BigInteger.ONE;

n--;

a = BigInteger.valueOf(n & 1);

n /= 2;

while (n-- > 0) {

a = a.add(b);

b = b.add(a);

}

return b;

}

return (n == 0) ? BigInteger.ZERO : BigInteger.ONE;

}

That implementation guarantees correctness as overflows can no longer occur.

However, it is not without problems because, again, it is quite slow: a call to

computeIterativelyFasterUsingBigInteger(50000) takes about 1.3 seconds to

complete. The lackluster performance can be explained by three things:

 BigInteger is immutable.

 BigInteger is implemented using BigInt and native code.

 The larger the numbers, the longer it takes to add them together.

Since BigInteger is immutable, we have to write “a = a.add(b)” instead of simply

“a.add(b)”. Many would assume “a.add(b)” is the equivalent of “a += b” and many would

be wrong: it is actually the equivalent of “a + b”. Therefore, we have to write “a =

a.add(b)” to assign the result. That small detail is extremely significant as “a.add(b)”

creates a new BigInteger object that holds the result of the addition.

Because of BigInteger’s current internal implementation, an additional BigInt object is

created for every BigInteger object that is allocated. This results in twice as many

objects being allocated during the execution of

computeIterativelyFasterUsingBigInteger: about 100,000 objects are created when

calling computeIterativelyFasterUsingBigInteger (50000) (and all of them but one will

become available for garbage collection almost immediately). Also, BigInt is

implemented using native code and calling native code from Java (using JNI) has a

certain overhead.

The third reason is that very large numbers do not fit in a single, long 64-bit value. For

example, the 50,000

Fibonacci number is 34,7111–bit long.

NOTE: BigInteger’s internal implementation (BigInteger.java) may change in future

Android releases. In fact, internal implementation of any class can change.

剩余277页未读，继续阅读

bobd988

粉丝: 0

深入优化Android应用性能

Pro Android Apps Performance Optimization 英文版源码

高清彩版 Pro iOS Apps Performance Optimization

Pro iOS Apps Performance Optimization

Pro iOS Apps Performance Optimization（iOS应用性能优化）

Apress.Pro.Android.Apps.Performance.Optimization.2012

Pro.iOS.Apps.Performance.Optimization

Apress.Pro.iOS.Apps.Performance.Optimization.Nov.2011

优化Android应用性能实战

深入探索Android应用性能优化

Android应用性能优化实战指南

最新资源