Google《Android性能优化》学习笔记

http://www.csdn.net/article/2015-04-15/2824477-android-performance/1

摘要：Google在Udacity上的《Android性能优化》在线课程详细介绍了该如何优化性能，这些课程是Google之前在Youtube上发布的Android性能优化典范专题课程的细化与补充。本文是对渲染、运算、内存、电量四个篇章的学习笔记。

Google近期在Udacity上发布了Android性能优化的在线课程，目前有三个篇章，分别从渲染，运算与内存，电量三个方面介绍了如何去优化性能，这些课程是Google之前在Youtube上发布的Android性能优化典范专题课程的细化与补充。

下面是渲染、运算、内存、电量四个篇章的学习笔记，部分内容和前面的性能优化典范有重合，欢迎大家一起学习交流！

渲染篇

1) Why Rendering Performance Matters

现在有不少App为了达到很华丽的视觉效果，会需要在界面上层叠很多的视图组件，但是这会很容易引起性能问题。如何平衡Design与Performance就很需要智慧了。

2) Defining ‘Jank’

大多数手机的屏幕刷新频率是60hz，如果在1000/60=16.67ms内没有办法把这一帧的任务执行完毕，就会发生丢帧的现象。丢帧越多，用户感受到的卡顿情况就越严重。

3) Rendering Pipeline: Common Problems

渲染操作通常依赖于两个核心组件：CPU与GPU。CPU负责包括Measure，Layout，Record，Execute的计算操作，GPU负责Rasterization(栅格化)操作。CPU通常存在的问题的原因是存在非必需的视图组件，它不仅仅会带来重复的计算操作，而且还会占用额外的GPU资源。

4) Android UI and the GPU

了解Android是如何利用GPU进行画面渲染有助于我们更好的理解性能问题。一个很直接的问题是：activity的画面是如何绘制到屏幕上的？那些复杂的XML布局文件又是如何能够被识别并绘制出来的？

Resterization栅格化是绘制那些Button，Shape，Path，String，Bitmap等组件最基础的操作。它把那些组件拆分到不同的像素上进行显示。这是一个很费时的操作，GPU的引入就是为了加快栅格化的操作。

CPU负责把UI组件计算成Polygons，Texture纹理，然后交给GPU进行栅格化渲染。

然而每次从CPU转移到GPU是一件很麻烦的事情，所幸的是OpenGL ES可以把那些需要渲染的纹理Hold在GPU Memory里面，在下次需要渲染的时候直接进行操作。所以如果你更新了GPU所hold住的纹理内容，那么之前保存的状态就丢失了。

在Android里面那些由主题所提供的资源，例如Bitmaps，Drawables都是一起打包到统一的Texture纹理当中，然后再传递到GPU里面，这意味着每次你需要使用这些资源的时候，都是直接从纹理里面进行获取渲染的。当然随着UI组件的越来越丰富，有了更多演变的形态。例如显示图片的时候，需要先经过CPU的计算加载到内存中，然后传递给GPU进行渲染。文字的显示比较复杂，需要先经过CPU换算成纹理，然后交给GPU进行渲染，返回到CPU绘制单个字符的时候，再重新引用经过GPU渲染的内容。动画则存在一个更加复杂的操作流程。

为了能够使得App流畅，我们需要在每帧16ms以内处理完所有的CPU与GPU的计算，绘制，渲染等等操作。

5) GPU Problem: Overdraw

Overdraw(过度绘制)描述的是屏幕上的某个像素在同一帧的时间内被绘制了多次。在多层次重叠的UI结构里面，如果不可见的UI也在做绘制的操作，会导致某些像素区域被绘制了多次。这样就会浪费大量的CPU以及GPU资源。

当设计上追求更华丽的视觉效果的时候，我们就容易陷入采用复杂的多层次重叠视图来实现这种视觉效果的怪圈。这很容易导致大量的性能问题，为了获得最佳的性能，我们必须尽量减少Overdraw的情况发生。

幸运的是，我们可以通过手机设置里面的开发者选项，打开Show GPU Overdraw的选项，观察UI上的Overdraw情况。

蓝色、淡绿、淡红、深红代表了4种不同程度的Overdraw情况，我们的目标就是尽量减少红色Overdraw，看到更多的蓝色区域。

6) Visualize and Fix Overdraw - Quiz & Solution

这里举了一个例子，通过XML文件可以看到有好几处非必需的background。通过把XML中非必需的background移除之后，可以显著减少布局的过度绘制。其中一个比较有意思的地方是：针对ListView中的Avatar ImageView的设置，在getView的代码里面，判断是否获取到对应的Bitmap，在获取到Avatar的图像之后，把ImageView的Background设置为Transparent，只有当图像没有获取到的时候才设置对应的Background占位图片，这样可以避免因为给Avatar设置背景图而导致的过度渲染。

总结一下，优化步骤如下：

• 移除Window默认的Background
• 移除XML布局文件中非必需的Background
• 按需显示占位背景图片

7) ClipRect & QuickReject

前面有提到过，对不可见的UI组件进行绘制更新会导致Overdraw。例如Nav Drawer从前置可见的Activity滑出之后，如果还继续绘制那些在Nav Drawer里面不可见的UI组件，这就导致了Overdraw。为了解决这个问题，Android系统会通过避免绘制那些完全不可见的组件来尽量减少Overdraw。那些Nav Drawer里面不可见的View就不会被执行浪费资源。

但是不幸的是，对于那些过于复杂的自定义的View(通常重写了onDraw方法)，Android系统无法检测在onDraw里面具体会执行什么操作，系统无法监控并自动优化，也就无法避免Overdraw了。但是我们可以通过canvas.clipRect()来帮助系统识别那些可见的区域。这个方法可以指定一块矩形区域，只有在这个区域内才会被绘制，其他的区域会被忽视。这个API可以很好的帮助那些有多组重叠组件的自定义View来控制显示的区域。同时clipRect方法还可以帮助节约CPU与GPU资源，在clipRect区域之外的绘制指令都不会被执行，那些部分内容在矩形区域内的组件，仍然会得到绘制。

除了clipRect方法之外，我们还可以使用canvas.quickreject()来判断是否没和某个矩形相交，从而跳过那些非矩形区域内的绘制操作。

8) Apply clipRect and quickReject - Quiz & Solution

上面的示例图中显示了一个自定义的View，主要效果是呈现多张重叠的卡片。这个View的onDraw方法如下图所示：

打开开发者选项中的显示过度渲染，可以看到我们这个自定义的View部分区域存在着过度绘制。那么是什么原因导致过度绘制的呢？

9) Fixing Overdraw with Canvas API

下面的代码显示了如何通过clipRect来解决自定义View的过度绘制，提高自定义View的绘制性能：

下面是优化过后的效果：

10) Layouts, Invalidations and Perf

Android需要把XML布局文件转换成GPU能够识别并绘制的对象。这个操作是在DisplayList的帮助下完成的。DisplayList持有所有将要交给GPU绘制到屏幕上的数据信息。

在某个View第一次需要被渲染时，Display List会因此被创建，当这个View要显示到屏幕上时，我们会执行GPU的绘制指令来进行渲染。

如果View的Property属性发生了改变（例如移动位置），我们就仅仅需要Execute Display List就够了。

然而如果你修改了View中的某些可见组件的内容，那么之前的DisplayList就无法继续使用了，我们需要重新创建一个DisplayList并重新执行渲染指令更新到屏幕上。

请注意：任何时候View中的绘制内容发生变化时，都会需要重新创建DisplayList，渲染DisplayList，更新到屏幕上等一系列操作。这个流程的表现性能取决于你的View的复杂程度，View的状态变化以及渲染管道的执行性能。举个例子，假设某个Button的大小需要增大到目前的两倍，在增大Button大小之前，需要通过父View重新计算并摆放其他子View的位置。修改View的大小会触发整个HierarcyView的重新计算大小的操作。如果是修改View的位置则会触发HierarchView重新计算其他View的位置。如果布局很复杂，这就会很容易导致严重的性能问题。

11) Hierarchy Viewer: Walkthrough

Hierarchy Viewer可以很直接的呈现布局的层次关系，视图组件的各种属性。 我们可以通过红，黄，绿三种不同的颜色来区分布局的Measure，Layout，Executive的相对性能表现如何。

12) Nested Hierarchies and Performance

提升布局性能的关键点是尽量保持布局层级的扁平化，避免出现重复的嵌套布局。例如下面的例子，有2行显示相同内容的视图，分别用两种不同的写法来实现，他们有着不同的层级。

下图显示了使用2种不同的写法，在Hierarchy Viewer上呈现出来的性能测试差异：

13) Optimizing Your Layout

下图举例演示了如何优化ListItem的布局，通过RelativeLayout替代旧方案中的嵌套LinearLayout来优化布局。

 

运算篇

1) Intro to Compute and Memory Problems

Android中的Java代码会需要经过编译优化再执行的过程。代码的不同写法会影响到Java编译器的优化效率。例如for循环的不同写法就会对编译器优化这段代码产生不同的效率，当程序中包含大量这种可优化的代码的时候，运算性能就会出现问题。想要知道如何优化代码的运算性能就需要知道代码在硬件层的执行差异。

2) Slow Function Performance

如果你写了一段代码，它的执行效率比想象中的要差很多。我们需要知道有哪些因素有可能影响到这段代码的执行效率。例如：比较两个float数值大小的执行时间是int数值的4倍左右。这是因为CPU的运算架构导致的，如下图所示：

虽然现代的CPU架构得到了很大的提升，也许并不存在上面所示的那么大的差异，但是这个例子说明了代码写法上的差异会对运算性能产生很大的影响。

通常来说有两类运行效率差的情况：第1种是相对执行时间长的方法，我们可以很轻松的找到这些方法并做一定的优化。第2种是执行时间短，但是执行频次很高的方法，因为执行次数多，累积效应下就会对性能产生很大的影响。

修复这些细节效率问题，需要使用Android SDK提供的工具，进行仔细的测量，然后再进行微调修复。

3) Traceview Walkthrough

通过Android Studio打开里面的Android Device Monitor，切换到DDMS窗口，点击左边栏上面想要跟踪的进程，再点击上面的Start Method Tracing的按钮，如下图所示：

启动跟踪之后，再操控app，做一些你想要跟踪的事件，例如滑动listview，点击某些视图进入另外一个页面等等。操作完之后，回到Android Device Monitor，再次点击Method Tracing的按钮停止跟踪。此时工具会为刚才的操作生成TraceView的详细视图。

关于TraceView中详细数据如何查看，这里不展开了，有很多文章介绍过。

4) Batching and Caching

为了提升运算性能，这里介绍2个非常重要的技术，Batching与Caching。

Batching是在真正执行运算操作之前对数据进行批量预处理，例如你需要有这样一个方法，它的作用是查找某个值是否存在与于一堆数据中。假设一个前提，我们会先对数据做排序，然后使用二分查找法来判断值是否存在。我们先看第一种情况，下图中存在着多次重复的排序操作。

在上面的那种写法下，如果数据的量级并不大的话，应该还可以接受，可是如果数据集非常大，就会有严重的效率问题。那么我们看下改进的写法，把排序的操作打包绑定只执行一次：

上面就是Batching的一种示例：把重复的操作拎出来，打包只执行一次。

Caching的理念很容易理解，在很多方面都有体现，下面举一个for循环的例子：

上面这2种基础技巧非常实用，积极恰当的使用能够显著提升运算性能。

5) Blocking the UI Thread

提升代码的运算效率是改善性能的一方面，让代码执行在哪个线程也同样很重要。我们都知道Android的Main Thread也是UI Thread，它需要承担用户的触摸事件的反馈，界面视图的渲染等操作。这就意味着，我们不能在Main Thread里面做任何非轻量级的操作，类似I/O操作会花费大量时间，这很有可能会导致界面渲染发生丢帧的现象，甚至有可能导致ANR。防止这些问题的解决办法就是把那些可能有性能问题的代码移到非UI线程进行操作。

6) Container Performance

另外一个我们需要注意的运算性能问题是基础算法的合理选择，例如冒泡排序与快速排序的性能差异：

避免我们重复造轮子，Java提供了很多现成的容器，例如Vector，ArrayList，LinkedList，HashMap等等，在Android里面还有新增加的SparseArray等，我们需要了解这些基础容器的性能差异以及适用场景。这样才能够选择合适的容器，达到最佳的性能。

内存篇

1) Memory, GC, and Performance

众所周知，与C/C++需要通过手动编码来申请以及释放内存有所不同，Java拥有GC的机制。Android系统里面有一个Generational Heap Memory的模型，系统会根据内存中不同的内存数据类型分别执行不同的GC操作。例如，最近刚分配的对象会放在Young Generation区域，这个区域的对象通常都是会快速被创建并且很快被销毁回收的，同时这个区域的GC操作速度也是比Old Generation区域的GC操作速度更快的。

除了速度差异之外，执行GC操作的时候，所有线程的任何操作都会需要暂停，等待GC操作完成之后，其他操作才能够继续运行。

通常来说，单个的GC并不会占用太多时间，但是大量不停的GC操作则会显著占用帧间隔时间(16ms)。如果在帧间隔时间里面做了过多的GC操作，那么自然其他类似计算，渲染等操作的可用时间就变得少了。

2) Memory Monitor Walkthrough

Android Studio中的Memory Monitor可以很好地帮助我们查看程序的内存使用情况。

3) Memory Leaks

内存泄漏表示的是不再用到的对象因为被错误引用而无法进行回收。

发生内存泄漏会导致Memory Generation中的剩余可用Heap Size越来越小，这样会导致频繁触发GC，更进一步引起性能问题。

举例内存泄漏，下面init()方法来自某个自定义View：

 private void init() {
 ListenerCollector collector = new ListenerCollector();
 collector.setListener(this, mListener);
 }

上面的例子容易存在内存泄漏，如果activity因为设备翻转而重新创建，自定义的View会自动重新把新创建出来的mListener给绑定到ListenerCollector中，但是当activity被销毁的时候，mListener却无法被回收了。

4) Heap Viewer Walkthrough

下图演示了Android Tools里面的Heap Viewer的功能，我们可以看到当前进程中的Heap Size的情况，分别有哪些类型的数据，占比是多少。

5) Understanding Memory Churn

Memory Churn内存抖动，内存抖动是因为在短时间内大量的对象被创建又马上被释放。瞬间产生大量的对象会严重占用Young Generation的内存区域，当达到阀值，剩余空间不够的时候，会触发GC从而导致刚产生的对象又很快被回收。即使每次分配的对象占用了很少的内存，但是他们叠加在一起会增加Heap的压力，从而触发更多其他类型的GC。这个操作有可能会影响到帧率，并使得用户感知到性能问题。

解决上面的问题有简洁直观方法，如果你在Memory Monitor里面查看到短时间发生了多次内存的涨跌，这意味着很有可能发生了内存抖动。

同时我们还可以通过Allocation Tracker来查看在短时间内，同一个栈中不断进出的相同对象。这是内存抖动的典型信号之一。

当你大致定位问题之后，接下去的问题修复也就显得相对直接简单了。例如，你需要避免在for循环里面分配对象占用内存，需要尝试把对象的创建移到循环体之外，自定义View中的onDraw方法也需要引起注意，每次屏幕发生绘制以及动画执行过程中，onDraw方法都会被调用到，避免在onDraw方法里面执行复杂的操作，避免创建对象。对于那些无法避免需要创建对象的情况，我们可以考虑对象池模型，通过对象池来解决频繁创建与销毁的问题，但是这里需要注意结束使用之后，需要手动释放对象池中的对象。

6) Allocation Tracker

关于Allocation Tracker工具的使用，不展开了，参考下面的链接：

• http://developer.android.com/tools/debugging/ddms.html#alloc
• http://android-developers.blogspot.com/2009/02/track-memory-allocations.html

7) Improve Your Code To Reduce Churn

下面演示一个例子，如何通过修改代码来避免内存抖动。优化之前的内存检测图：

定位代码之后，修复了String拼接的问题：

优化之后的内存监测图：

8) Recap

上面提到了三种测量内存的工具，下面再简要概括一下他们各自的特点：

• Memory Monitor：跟踪整个app的内存变化情况。
• Heap Viewer：查看当前内存快照，便于对比分析哪些对象有可能发生了泄漏。
• Allocation Tracker：追踪内存对象的来源。

电量篇

1) Understanding Battery Drain

手机各个硬件模块的耗电量是不一样的，有些模块非常耗电，而有些模块则相对显得耗电量小很多。

电量消耗的计算与统计是一件麻烦而且矛盾的事情，记录电量消耗本身也是一个费电量的事情。唯一可行的方案是使用第三方监测电量的设备，这样才能够获取到真实的电量消耗。

当设备处于待机状态时消耗的电量是极少的，以N5为例，打开飞行模式，可以待机接近1个月。可是点亮屏幕，硬件各个模块就需要开始工作，这会需要消耗很多电量。

使用WakeLock或者JobScheduler唤醒设备处理定时的任务之后，一定要及时让设备回到初始状态。每次唤醒蜂窝信号进行数据传递，都会消耗很多电量，它比WiFi等操作更加的耗电。

2) Battery Historian

Battery Historian是Android 5.0开始引入的新API。通过下面的指令，可以得到设备上的电量消耗信息：

$ adb shell dumpsys batterystats > xxx.txt  //得到整个设备的电量消耗信息
$ adb shell dumpsys batterystats > com.package.name > xxx.txt //得到指定app相关的电量消耗信息

得到了原始的电量消耗数据之后，我们需要通过Google编写的一个python脚本把数据信息转换成可读性更好的html文件：

$ python historian.py xxx.txt > xxx.html

打开这个转换过后的html文件，可以看到类似TraceView生成的列表数据，这里的数据信息量很大，这里就不展开了。

3) Track Battery Status & Battery Manager

我们可以通过下面的代码来获取手机的当前充电状态：

 // It is very easy to subscribe to changes to the battery state, but you can get the current
 // state by simply passing null in as your receiver.  Nifty, isn't that?
 IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
 Intent batteryStatus = this.registerReceiver(null, filter);
 int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
 boolean acCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_AC);
 if (acCharge) {
     Log.v(LOG_TAG,“The phone is charging!”);
 }

在上面的例子演示了如何立即获取到手机的充电状态，得到充电状态信息之后，我们可以有针对性的对部分代码做优化。比如我们可以判断只有当前手机为AC充电状态时 才去执行一些非常耗电的操作。

 /**
  * This method checks for power by comparing the current battery state against all possible
  * plugged in states. In this case, a device may be considered plugged in either by USB, AC, or
  * wireless charge. (Wireless charge was introduced in API Level 17.)
  */
 private boolean checkForPower() {
     // It is very easy to subscribe to changes to the battery state, but you can get the current
     // state by simply passing null in as your receiver.  Nifty, isn't that?
     IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
     Intent batteryStatus = this.registerReceiver(null, filter);

     // There are currently three ways a device can be plugged in. We should check them all.
     int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
     boolean usbCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_USB);
     boolean acCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_AC);
     boolean wirelessCharge = false;
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
         wirelessCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_WIRELESS);
     }
     return (usbCharge || acCharge || wirelessCharge);
 }

4) Wakelock and Battery Drain

高效的保留更多的电量与不断促使用户使用你的App会消耗电量，这是矛盾的选择题。不过我们可以使用一些更好的办法来平衡两者。

假设你的手机里面装了大量的社交类应用，即使手机处于待机状态，也会经常被这些应用唤醒用来检查同步新的数据信息。Android会不断关闭各种硬件来延长手机的待机时间，首先屏幕会逐渐变暗直至关闭，然后CPU进入睡眠，这一切操作都是为了节约宝贵的电量资源。但是即使在这种睡眠状态下，大多数应用还是会尝试进行工作，他们将不断的唤醒手机。一个最简单的唤醒手机的方法是使用PowerManager.WakeLock的API来保持CPU工作并防止屏幕变暗关闭。这使得手机可以被唤醒，执行工作，然后回到睡眠状态。知道如何获取WakeLock是简单的，可是及时释放WakeLock也是非常重要的，不恰当的使用WakeLock会导致严重错误。例如网络请求的数据返回时间不确定，导致本来只需要10s的事情一直等待了1个小时，这样会使得电量白白浪费了。这也是为何使用带超时参数的wakelock.acquice()方法是很关键的。

但是仅仅设置超时并不足够解决问题，例如设置多长的超时比较合适？什么时候进行重试等等？解决上面的问题，正确的方式可能是使用非精准定时器。通常情况下，我们会设定一个时间进行某个操作，但是动态修改这个时间也许会更好。例如，如果有另外一个程序需要比你设定的时间晚5分钟唤醒，最好能够等到那个时候，两个任务捆绑一起同时进行，这就是非精确定时器的核心工作原理。我们可以定制计划的任务，可是系统如果检测到一个更好的时间，它可以推迟你的任务，以节省电量消耗。

这正是JobScheduler API所做的事情。它会根据当前的情况与任务，组合出理想的唤醒时间，例如等到正在充电或者连接到WiFi的时候，或者集中任务一起执行。我们可以通过这个API实现很多免费的调度算法。

5) Network and Battery Drain

下面内容来自官方Training文档中高效下载章节关于手机(Radio)蜂窝信号对电量消耗的介绍。

通常情况下，使用3G移动网络传输数据，电量的消耗有三种状态：

• Full power: 能量最高的状态，移动网络连接被激活，允许设备以最大的传输速率进行操作。
• Low power: 一种中间状态，对电量的消耗差不多是Full power状态下的50%。
• Standby: 最低的状态，没有数据连接需要传输，电量消耗最少。

下图是一个典型的3G Radio State Machine的图示(来自AT&T，详情请点击这里)：

总之，为了减少电量的消耗，在蜂窝移动网络下，最好做到批量执行网络请求，尽量避免频繁的间隔网络请求。

通过前面学习到的Battery Historian我们可以得到设备的电量消耗数据，如果数据中的移动蜂窝网络(Mobile Radio)电量消耗呈现下面的情况，间隔很小，又频繁断断续续的出现，说明电量消耗性能很不好：

经过优化之后，如果呈现下面的图示，说明电量消耗的性能是良好的：

另外WiFi连接下，网络传输的电量消耗要比移动网络少很多，应该尽量减少移动网络下的数据传输，多在WiFi环境下传输数据。

那么如何才能够把任务缓存起来，做到批量化执行呢？下面就轮到Job Scheduler出场了。

6) Using Job Scheduler

使用Job Scheduler，应用需要做的事情就是判断哪些任务是不紧急的，可以交给Job Scheduler来处理，Job Scheduler集中处理收到的任务，选择合适的时间，合适的网络，再一起进行执行。

下面是使用Job Scheduler的一段简要示例，需要先有一个JobService：

 public class MyJobService extends JobService {
     private static final String LOG_TAG = "MyJobService";

     @Override
     public void onCreate() {
         super.onCreate();
         Log.i(LOG_TAG, "MyJobService created");
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         Log.i(LOG_TAG, "MyJobService destroyed");
     }

     @Override
     public boolean onStartJob(JobParameters params) {
         // This is where you would implement all of the logic for your job. Note that this runs
         // on the main thread, so you will want to use a separate thread for asynchronous work
         // (as we demonstrate below to establish a network connection).
         // If you use a separate thread, return true to indicate that you need a "reschedule" to
         // return to the job at some point in the future to finish processing the work. Otherwise,
         // return false when finished.
         Log.i(LOG_TAG, "Totally and completely working on job " + params.getJobId());
         // First, check the network, and then attempt to connect.
         if (isNetworkConnected()) {
             new SimpleDownloadTask() .execute(params);
             return true;
         } else {
             Log.i(LOG_TAG, "No connection on job " + params.getJobId() + "; sad face");
         }
         return false;
     }

     @Override
     public boolean onStopJob(JobParameters params) {
         // Called if the job must be stopped before jobFinished() has been called. This may
         // happen if the requirements are no longer being met, such as the user no longer
         // connecting to WiFi, or the device no longer being idle. Use this callback to resolve
         // anything that may cause your application to misbehave from the job being halted.
         // Return true if the job should be rescheduled based on the retry criteria specified
         // when the job was created or return false to drop the job. Regardless of the value
         // returned, your job must stop executing.
         Log.i(LOG_TAG, "Whelp, something changed, so I'm calling it on job " + params.getJobId());
         return false;
     }

     /**
      * Determines if the device is currently online.
      */
     private boolean isNetworkConnected() {
         ConnectivityManager connectivityManager =
                 (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
         NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
         return (networkInfo != null && networkInfo.isConnected());
     }

     /**
      *  Uses AsyncTask to create a task away from the main UI thread. This task creates a
      *  HTTPUrlConnection, and then downloads the contents of the webpage as an InputStream.
      *  The InputStream is then converted to a String, which is logged by the
      *  onPostExecute() method.
      */
     private class SimpleDownloadTask extends AsyncTask {

         protected JobParameters mJobParam;

         @Override
         protected String doInBackground(JobParameters... params) {
             // cache system provided job requirements
             mJobParam = params[0];
             try {
                 InputStream is = null;
                 // Only display the first 50 characters of the retrieved web page content.
                 int len = 50;

                 URL url = new URL("https://www.google.com");
                 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                 conn.setReadTimeout(10000); //10sec
                 conn.setConnectTimeout(15000); //15sec
                 conn.setRequestMethod("GET");
                 //Starts the query
                 conn.connect();
                 int response = conn.getResponseCode();
                 Log.d(LOG_TAG, "The response is: " + response);
                 is = conn.getInputStream();

                 // Convert the input stream to a string
                 Reader reader = null;
                 reader = new InputStreamReader(is, "UTF-8");
                 char[] buffer = new char[len];
                 reader.read(buffer);
                 return new String(buffer);

             } catch (IOException e) {
                 return "Unable to retrieve web page.";
             }
         }

         @Override
         protected void onPostExecute(String result) {
             jobFinished(mJobParam, false);
             Log.i(LOG_TAG, result);
         }
     }
 }

然后模拟通过点击Button触发N个任务，交给JobService来处理：

 public class FreeTheWakelockActivity extends ActionBarActivity {
     public static final String LOG_TAG = "FreeTheWakelockActivity";

     TextView mWakeLockMsg;
     ComponentName mServiceComponent;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_wakelock);

         mWakeLockMsg = (TextView) findViewById(R.id.wakelock_txt);
         mServiceComponent = new ComponentName(this, MyJobService.class);
         Intent startServiceIntent = new Intent(this, MyJobService.class);
         startService(startServiceIntent);

         Button theButtonThatWakelocks = (Button) findViewById(R.id.wakelock_poll);
         theButtonThatWakelocks.setText(R.string.poll_server_button);

         theButtonThatWakelocks.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                     pollServer();
             }
         });
     }

     /**
      * This method polls the server via the JobScheduler API. By scheduling the job with this API,
      * your app can be confident it will execute, but without the need for a wake lock. Rather, the
      * API will take your network jobs and execute them in batch to best take advantage of the
      * initial network connection cost.
      *
      * The JobScheduler API works through a background service. In this sample, we have
      * a simple service in MyJobService to get you started. The job is scheduled here in
      * the activity, but the job itself is executed in MyJobService in the startJob() method. For
      * example, to poll your server, you would create the network connection, send your GET
      * request, and then process the response all in MyJobService. This allows the JobScheduler API
      * to invoke your logic without needed to restart your activity.
      *
      * For brevity in the sample, we are scheduling the same job several times in quick succession,
      * but again, try to consider similar tasks occurring over time in your application that can
      * afford to wait and may benefit from batching.
      */
     public void pollServer() {
         JobScheduler scheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
         for (int i=0; i<10; i++) {
             JobInfo jobInfo = new JobInfo.Builder(i, mServiceComponent)
                     .setMinimumLatency(5000) // 5 seconds
                     .setOverrideDeadline(60000) // 60 seconds (for brevity in the sample)
                     .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) // WiFi or data connections
                     .build();

             mWakeLockMsg.append("Scheduling job " + i + "!\n");
             scheduler.schedule(jobInfo);
         }
     }
 }

作者介绍：胡凯（@胡凯me），就职于腾讯，从事Android开发的工作，个人博客：http://hukai.me/。

---

CSDN移动将持续为您优选移动开发的精华内容，共同探讨移动开发的技术热点话题，涵盖移动应用、开发工具、移动游戏及引擎、智能硬件、物联网等方方面面，如果您有想分享的技术、观点，可通过电子邮件（tangxy#csdn.net，请把#改成@）投稿。

第一时间关注最新移动开发相关信息和技术，请关注mobilehub公众微信号（ID: mobilehub)。