深入探索Android应用性能优化

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

"Android应用性能优化，这是一本关于Android应用性能提升的专业书籍，作者Hervé Guihot提供了全面的优化策略和技术。" 在Android开发中，应用性能优化是确保用户体验的关键环节。本书"Pro Android Apps Performance Optimization"深入探讨了如何通过多种方法提升Android应用程序的性能。以下是书中可能涵盖的一些关键知识点： 1. **内存管理**：优化内存使用是Android性能优化的核心。书中可能会讲解如何有效地使用内存，避免内存泄漏，以及如何通过分析工具（如Android Profiler）监控和调试内存问题。 2. **渲染性能**：Android应用的UI流畅性至关重要。优化包括减少布局层级，使用高效绘制的自定义View，以及合理利用硬件加速。书中可能介绍了如何利用 Choreographer、RenderThread 和 GPU 渲染路径来提高帧率。 3. **后台服务与电池寿命**：优化后台服务以减少电量消耗。这涉及合理调度任务，使用JobScheduler、WorkManager等API，以及避免无谓的唤醒锁。 4. **代码优化**：书中可能会探讨Java和Kotlin编程的最佳实践，如避免过度使用对象，使用适当的数据结构，以及理解并应用Dalvik字节码优化。 5. **资源压缩与加载**：优化资源文件大小可以加快应用的启动速度和运行效率。可能包括图片压缩、选择正确的资源密度、使用Nine-Patch图像等。 6. **网络与数据存储**：优化网络请求，使用缓存策略，如使用OkHttp或Retrofit库。数据存储方面，合理选择SQLite、ContentProvider、Room数据库或本地文件系统。 7. **多线程与并发**：理解并正确使用线程池、IntentService、AsyncTask、协程（Kotlin）等机制，避免线程安全问题，提高应用响应速度。 8. **测试与调试**：介绍各种测试策略，如单元测试、集成测试、压力测试，以及使用Monkey、Systrace、Tracer等工具进行性能分析和调试。 9. **性能基准和监控**：通过工具如Traceview、CPU Profiler、Memory Profiler进行性能基准测试，实时监控应用的性能状态。 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页未读，继续阅读

sylcc_

粉丝: 60
资源: 7

深入探索Android应用性能优化

Android应用性能优化_人民邮电出版社

android应用性能优化

Android应用性能优化 开发优秀的Android应用必备指南

Android应用性能优化.pdf

Android应用性能优化 中文版

android应用性能优化.rar

《Android应用性能优化》

深入探索Android应用性能优化

深入解析Android应用性能优化

Android应用性能优化实战指南

最新资源

Android应用性能优化开发优秀的Android应用必备指南

Android应用性能优化中文版