优化Android应用性能实战

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

"Pro Android Apps Performance Optimization" 本书"Pro Android Apps Performance Optimization"专注于提升Android应用程序的性能，由Hervé Guihot撰写，详细介绍了如何优化Android应用的各个方面，以提高其运行效率、用户体验以及整体质量。这是一本面向专业Android开发者的指南，旨在帮助他们掌握优化技巧，以达到最佳的性能标准。书中可能涵盖了以下关键知识点： 1. **性能分析工具**：介绍了一系列用于检测和解决性能问题的工具，如Android Profiler、Traceview、Systrace等，这些工具可以帮助开发者识别内存泄漏、CPU过度使用和UI卡顿等问题。 2. **代码优化**：讨论了Java和Kotlin编程语言的最佳实践，包括避免不必要的对象创建、减少内存占用、优化循环和算法，以及如何利用多线程和并发来提高执行效率。 3. **布局优化**：讲解了如何优化XML布局文件，减少视图层次，使用Merge标签，以及使用Data Binding和ViewBinding技术来提高UI性能。 4. **资源管理和内存优化**：探讨了如何有效地管理内存，避免内存泄漏，以及合理使用Bitmap和Drawables以减少内存消耗。 5. **渲染优化**：讲述了如何优化帧率，使用硬件加速，以及减少过度绘制，以实现流畅的动画和用户交互。 6. **后台服务和后台任务优化**：讨论了IntentService、JobScheduler、WorkManager等后台处理机制的使用，以及如何避免唤醒锁的滥用，确保应用在后台运行时的效率和电池续航。 7. **数据库优化**：介绍了SQLite数据库的正确使用，包括高效的查询编写、索引创建和数据缓存策略，以加快数据访问速度。 8. **网络和数据传输优化**：讲解了如何通过HTTP/2、Gzip压缩、WebSocket等技术减少网络延迟，以及如何使用Retrofit、OkHttp等库进行高效的网络请求。 9. **APK大小优化**：探讨了如何减小APK的体积，使用APK Split、Dex分包、资源压缩等方法，以提高下载和安装速度。 10. **测试与调试**：强调了持续集成和自动化测试的重要性，以及如何使用单元测试、集成测试和性能测试来确保应用的质量。这本书是Android开发者必备的参考书，通过深入学习，开发者可以提升自己的专业技能，打造出运行更加流畅、资源消耗更低的高质量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页未读，继续阅读

newtoncau

粉丝: 5
资源: 187

优化Android应用性能实战

优化Android应用性能的关键策略

深入优化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应用性能优化

最新资源