优化Android应用性能实战

5星 · 超过95%的资源需积分: 0 4 浏览量更新于2024-07-26 1 收藏 2.63MB PDF 举报

"《Pro Android Apps Performance Optimization》是由法国MTK开发人员Hervé Guihot撰写的一本关于Android应用性能优化的专业书籍。本书全面探讨了Android应用在性能方面可能遇到的各种问题及其解决方案，旨在帮助开发者提升应用的运行效率、响应速度和用户体验。" 在Android应用开发中，性能优化是至关重要的一个环节，它涉及到多个层面，包括内存管理、CPU使用率、UI流畅性、电池消耗以及数据加载等。《Pro Android Apps Performance Optimization》深入浅出地讲解了这些关键领域： 1. **内存管理**：书中会介绍如何有效地分配和释放内存，避免内存泄漏，以及使用内存分析工具来检测和定位内存问题。此外，还会讲解如何优化对象生命周期，减少不必要的对象创建，提高内存利用率。 2. **CPU使用率优化**：作者可能会分享如何通过代码优化降低CPU的使用率，如避免无用的后台线程，减少同步操作，以及使用更高效的数据结构和算法。 3. **UI性能**：书中会涉及如何优化布局，减少重绘，使用硬件加速，以及运用 Choreographer 和 RenderThread 来提高帧率，确保应用的流畅性。 4. **电池寿命**：开发者将学习如何减少唤醒锁的使用，优化网络请求，合理调度任务，以减少对电池的消耗。 5. **数据加载与缓存**：讨论如何实现高效的数据加载策略，比如使用分页加载，缓存策略，以及利用Android的Loader框架和Room数据库来优化数据访问。 6. **图形和渲染优化**：书中可能会涵盖如何使用OpenGL ES进行图形处理，减少过度绘制，以及如何优化图像资源，提高渲染效率。 7. **性能监控和调试**：介绍各种Android性能分析工具，如Android Profiler，Traceview，Systrace等，帮助开发者发现并解决问题。 8. **代码结构和设计模式**：强调良好的编程习惯和设计模式的应用，如模块化、组件化，以及使用MVVM等架构模式，以提高代码的可读性和可维护性。 9. **多线程和并发**：讲解如何有效地使用线程池，理解并发和同步的概念，以及避免线程间的竞态条件和死锁。 10. **APK瘦身**：介绍如何减小应用的安装包大小，包括压缩资源，去除冗余库，使用增量更新等技术。这本书不仅适合有经验的Android开发者深入学习，也适合作为初学者的进阶指南，帮助他们从一开始就养成良好的性能优化意识。通过阅读《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页未读，继续阅读

欧军礼

粉丝: 198
资源: 2

优化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应用性能优化实战指南

最新资源