Android性能优化系列---Sending Operations to Multiple Threads
本文源自：http://developer.android.com/training/multiple-threads/index.html
当你将一个需要长时间运行的，数据量大的操作，分割成一些小的操作，并且在多线程中运行的话，那么这个长时间运行的操作的速度和效率将会提升不少。对于有一个有多个处理器（多核）的CPU的设备，系统可以并发的运行多个线程，而不是让每个子操作等到被执行。比如，当你要解码多张图片，以在屏幕上显示的话，你如果将每一个图片的解码操作放在每一个独立的线程的话，那么速度将会很快。
本课程将会向你展示，在Android里如何通过一个线程池对象，来创立和使用多线程。你同样也会学到如何使得代码在线程中运行，以及这些线程如何与主线程通信。
Specifying the Code to Run on a Thread
学习怎么写代码让其运行在一个单一的线程（通过定义一个实现Runnable接口的类）。
Creating a Manager for Multiple Threads
学习如何产生一个管理线程池的类和Runnable队列。该管理线程池的对象叫ThreadPoolExecutor。
Running Code on a Thread Pool Thread
怎么在线程池里在Thread上运行Runnable任务
Communicating with the UI Thread
如何让线程池里的线程和UI线程通信
Specifying the Code to Run on a Thread
Thread和Runnable是java里的基本类，但在Android里仅仅使用它们处理和解决问题有限。但它们是Android里例如HandlerThread、AsyncTask和IntentService等这些功能强大的类的基础。Thread和Runnable也是ThreadPoolExecutor类的基础。这个类自动的管理线程和任务队列，并且能并发的运行多线程。
Define a Class that Implements Runnable
定义一个类实现Runnable接口是直接明了的方式，例如：
public class PhotoDecodeRunnable implements Runnable {
...
@Override
public void run() {
/*
* Code you want to run on the thread goes here
*/
...
}
...
}
Implement the run() Method
在这个类里，Runnable.run()方法包含被执行的代码。通常，任何执行代码都被运行在Runnable里。但请记住，因为Runnable不被运行在UI thread，因此，不要直接的更新UI对象（例如像View对象）。为了通信和UI线程，你必须使用在Communicate with the UI Thread章节介绍的技术。
在run()方法里，通过调用Process.setThreadPriority()设置Thread的级别为background priority（ THREAD_PRIORITY_BACKGROUND）。这种方式能降低运行Runnable的线程和UI线程之间的资源竞争。你也应该在Runnble对象里持有运行该Runnable对象的线程的引用。通过调用Thread.currentThread()。
下面的代码片段告诉你怎么写run（）方法。
class PhotoDecodeRunnable implements Runnable {
...
/*
* Defines the code to run for this task.
*/
@Override
public void run() {
// Moves the current Thread into the background android.os.Process.setThreadPriority
(android.os.Process.THREAD_PRIORITY_BACKGROUND);
...
/*
* Stores the current Thread in the PhotoTask instance,
* so that the instance
* can interrupt the Thread.
*/
mPhotoTask.setImageDecodeThread(Thread.currentThread());
...
}
...
}
Creating a Manager for Multiple Threads
前面告诉你如何定义一个运行在单一线程上的任务。如果你仅仅想运行该任务一次，上面的方式就能满足你的要求。如果你想在不同的数据集上多次运行该任务。但是一次又仅仅运行一次，IntentService能满足你的需求。为了资源可用时自动运行任务或者同时运行多个任务，你需要你个管理线程线程的集合。为了做这，可用使用ThreadPoolExecutor，ThreadPoolExecutor依次的从任务队列中取一个任务运行。为了运行一个任务，所有你必须做的就是将该任务加入到任务队列里。
线程池能并发运行多个任务，因此你必须保证你的代码是线程安全的。确保把能被多个线程访问的变量放在同步代码块里。这能避免一个线程对某个变量读的同时另一个线程对该变量写。特别地，当该变量是静态变量时这种情况更容易出现，当然，这种情况也发生在仅仅实例一次的对象上。如果想了解更多，请阅读Processes and Threads
Define the Thread Pool Class
在某个类里（管理线程池的类）实例化ThreadPoolExecutor。在这个类，做如下事情：
为线程池使用静态变量
在你的应用里，为了对于有限的CPU和网络资源有单一的控制点，你可能需要该线程池是单例的。如果你有许多不同类型的任务，你就不得不对于每一个类型的Runnable实例不同的线程池，但每一种类型的Runnable只对应有一个ThreadPoolExecutor实例。例如，你可以定义该类作为你全局属性声明的一部分：
public class PhotoManager {
...
static {
...
// Creates a single static instance of PhotoManager
sInstance = new PhotoManager();
}
...
用一个私有构造器确保该类单例，那意思是你不必在同步代码块里封装对该类的访问。
public class PhotoManager {
...
/**
* Constructs the work queues and thread pools used to download
* and decode images. Because the constructor is marked private,
* it's unavailable to other classes, even in the same package.
*/
private PhotoManager() {
...
}
通过调用线程池里的方法开始你的任务
在线程里定义一个方法，该方法加一个任务到线程池队列里。例如：
public class PhotoManager {
...
// Called by the PhotoView to get a photo
static public PhotoTask startDownload(PhotoView imageView,boolean cacheFlag) {
...
// Adds a download task to the thread pool for execution sInstance.
mDownloadThreadPool.execute(downloadTask.getHTTPDownloadRunnable());
...
}
在Manager类的构造器里实例化一个Handler，让该Handler附加到UI线程上。Handler运行你放心的调用UI对象例如View里的方法。大多数的UI对象仅仅在UI线程里才是线程安全的。UI线程和非UI线程通信，更多的信息请参考Communicate with the UI Thread。例如：
private PhotoManager() {
...
// Defines a Handler object that's attached to the UI thread
mHandler = new Handler(Looper.getMainLooper()) {
/*
* handleMessage() defines the operations to perform when
* the Handler receives a new Message to process.
*/
@Override
public void handleMessage(Message inputMessage) {
...
}
...
}
}
Determine the Thread Pool Parameters
一旦你有了总体的类架构，你能开始定义线程池。为了实例一个线程池对象，你需要如下的值：
初始化池大小和最大池大小
分配给线程池的初始化线程个数和最大能运行的线程个数。在线程池里能有的线程的数量主要取决于你的设备的CPU核数。你可以从系统环境里获取该有效数：
public class PhotoManager {
...
/*
* Gets the number of available cores
* (not always the same as the maximum number of cores)
*/
private static int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
}
这个数量可能并不反映你的设备的CPU的物理核数。有些设备的CPU一些处理器可能并不是活跃的。那即是有些核可能并没有使用。对应这些设备， availableProcessors() 返回活动的核数，这可能比总核数少。
保持活动时间和时间单位
线程关闭之前可以处于idle状态持续的时间。时间单位取值于TimeUnit类的常量之一。定义了Keep alive time的单位。
任务队列：
任务队列将传入ThreadPoolExecutor里，ThreadPoolExecutor从该任务队列里去取Runnable对象运行。为了在一个线程上运行代码，线程池管理器从一个先进先出队列取Runnable对象。然后分配其到一个线程运行。当你产生线程池的时候，你能传入该队列对象。任何实现了BlockingQueue接口的对象都可以作为任务队列对象。
为了了解更多，可以参考类ThreadPoolExecutor。使用LinkedBlockingQueue类的示例如下：
public class PhotoManager {
...
private PhotoManager() {
...
// A queue of Runnables
private final BlockingQueue<Runnable> mDecodeWorkQueue;
...
// Instantiates the queue of Runnables as a LinkedBlockingQueue
mDecodeWorkQueue = new LinkedBlockingQueue<Runnable>();
...
}
...
}
Create a Pool of Threads
为了产生一个线程池，通过调用ThreadPoolExecutor（）方法实例化一个线程池管理器。其产生和管理一个线程组。因为初始化线程组和最大线程数是相同的，ThreadPoolExecutor会在它实例化的时候就产生所有的线程对象。例如：
private PhotoManager() {
...
// Sets the amount of time an idle thread waits before terminating
private static final int KEEP_ALIVE_TIME = 1;
// Sets the Time Unit to seconds
private static final TimeUnit KEEP_ALIVE_TIME_UNIT = TimeUnit.SECONDS;
// Creates a thread pool manager
mDecodeThreadPool = new ThreadPoolExecutor(
NUMBER_OF_CORES, // Initial pool size
NUMBER_OF_CORES, // Max pool size
KEEP_ALIVE_TIME,
KEEP_ALIVE_TIME_UNIT,
mDecodeWorkQueue);
}
Running Code on a Thread Pool Thread
前面论述了怎么定义一个线程池管理类及如何定义运行在里的任务。现在我们将讨论如何在一个线程池里运行一个任务。为了实现这，你需要将你的任务加到一个线程池工作队列。当线程变得有效时ThreadPool -Executor从该队列取一个任务然后运行它。
这课也告诉你如何停止一个正在运行的任务。你可能在一个任务开始的时候你想要停止它。为了不浪费CPU时间，你能取消正在运行的任务。例如，你正从网络下载图片，并使用了缓存。你可能当发现该图片已缓存时需要停止该线程任务。由于你的应用代码实现的原因。你可能在发生了网络请求时才知道该图片是否已缓存。
Run a Task on a Thread in the Thread Pool
为了在线程池里运行一个任务，传递一个Runnable对象到ThreadPoolExecutor.execute()即可。执行execute（）会将该任务加到线程池的任务队列。当一个处于Idle的线程可以运行时，线程池管理器取等待时间最长的任务运行：
public class PhotoManager {
public void handleState(PhotoTask photoTask, int state) {
switch (state) {
// The task finished downloading the image
case DOWNLOAD_COMPLETE:
// Decodes the image
mDecodeThreadPool.execute(photoTask.getPhotoDecodeRunnable());
...
}
...
}
...
}
当ThreadPoolExecutor在一个Thread运行Runnable时，它会自动的调用Runnable的run（）方法。
为了停止一个任务。你需要中断运行该任务的线程。为了能这样做。当你产生一个任务的时候，你需要持有该任务线程的句柄。例如：
class PhotoDecodeRunnable implements Runnable {
// Defines the code to run for this task
public void run() {
/*
* Stores the current Thread in the
* object that contains PhotoDecodeRunnable
*/
mPhotoTask.setImageDecodeThread(Thread.currentThread());
...
}
...
}
为了中断该线程，调用Thread.interrupt().注意，线程是由系统控制的。系统能在你的应用进程之外修改该线程。因此，在你中断该线程之前，你需要在该线程上对你的取消操作加锁：将代码放入同步代码块。例如：
public class PhotoManager {
public static void cancelAll() {
/*
* Creates an array of Runnables that's the same size as the
* thread pool work queue
*/
Runnable[] runnableArray = new Runnable[mDecodeWorkQueue.size()];
// Populates the array with the Runnables in the queue
mDecodeWorkQueue.toArray(runnableArray);
// Stores the array length in order to iterate over the array
int len = runnableArray.length;
/*
* Iterates over the array of Runnables and interrupts each one's Thread.
*/
synchronized (sInstance) {
// Iterates over the array of tasks
for (int runnableIndex = 0; runnableIndex < len; runnableIndex++) {
// Gets the current thread
Thread thread = runnableArray[taskArrayIndex].mThread;
// if the Thread exists, post an interrupt to it
if (null != thread) {
thread.interrupt();
}
}
}
}
...
}
大多数情况下，Thread.interrupte()立即的停止线程。然而，该方法仅仅停止处于waiting状态的线程，不中断CPU或者网络任务。为了避免系统变慢或者系统被锁，你应该在试图执行该操作前测试该中断请求。
/*
* Before continuing, checks to see that the Thread hasn't been interrupted
*/
if (Thread.interrupted()) {
return;
}
...
// Decodes a byte array into a Bitmap (CPU-intensive)
BitmapFactory.decodeByteArray(imageBuffer, 0, imageBuffer.length, bitmapOptions);
...
Communicating with the UI Thread
上一节你知道了怎么在一个线程上开始一个任务。该线程通过ThreadPoolExecutor管理。最后，你需要在UI线程上更新在子线程里运行的结果。每一个app都有一个专门运行UI对象例如View的线程。只有在UI线程里才能进行UI操作。因为运行在线程里的任务并不运行在UI线程，不能在该线程里访问UI对象。为了让后台运行的任务的数据结果更新到UI上，可以使用一个运行在UI线程上的Handler。
Define a Handler on the UI Thread
Handler是Android系统框架提供的管理Thread的一个类。Handler收到消息并且运行相关代码处理该消息。正常地，你可以为一个新线程产生一个Handler。你也可以将该handler连接到一个已存在的线程。当你连接一个Handler到UI线程时，该Handler将处理消息到UI线程。
在产生线程池类（将该类定义为全局变量，例如通过单例）的构造方法里实例化Handler。通过Handler （Looper）构造方法连接该Handler到UI线程。该构造器使用Looper对象。当你基于特定的Looper对象实例化你的Handler时，该Handler运行于和Looper一样的线程，例如：
private PhotoManager() {
...
// Defines a Handler object that's attached to the UI thread
mHandler = new Handler(Looper.getMainLooper()) {
...
在Handler内部，你要重写handleMessage()方法。当Handler接收到来自它附属的线程发来的消息时，系统会自动调用handleMessage方法。在Handler内部，你要重写handleMessage()方法。当Handler接收到来自它附属的线程发来的消息时，系统会自动调用handleMessage方法。一个线程里所有的Handler对象将会同时接收到来自于该线程的消息。例如：
/*
* handleMessage() defines the operations to perform when
* the Handler receives a new Message to process.
*/
@Override
public void handleMessage(Message inputMessage) {
// Gets the image task from the incoming Message object.
PhotoTask photoTask = (PhotoTask) inputMessage.obj;
...
}
...
}
}
Move Data from a Task to the UI Thread
如果想将工作线程运行的数据传递给主线程中的某个对象，可以在任务中存储这个数据和UI对象的引用。接下来，将这个任务还有执行这个任务后的状态码传递给创建handler的对象。在这个对象中，将包含这个状态码以及任务对象的消息发送给handler。由于handler运行在主线程中，因此它可以将任务产生的结果传递给主线程。
Store data in the task object
例如,下面是一个运行在后台非UI线程，用于解码Bitmap和在它的父类PhotoTask里存储Bitmap的Runnable。该Runnable也存储状态码：DECODE_STATE_COMPLETED。
// A class that decodes photo files into Bitmaps
class PhotoDecodeRunnable implements Runnable {
...
PhotoDecodeRunnable(PhotoTask downloadTask) {
mPhotoTask = downloadTask;
}
...
// Gets the downloaded byte array
byte[] imageBuffer = mPhotoTask.getByteBuffer();
...
// Runs the code for this task
public void run() {
...
// Tries to decode the image buffer
returnBitmap = BitmapFactory.decodeByteArray(
imageBuffer,
0,
imageBuffer.length,
bitmapOptions
);
...
// Sets the ImageView Bitmap
mPhotoTask.setImage(returnBitmap);
// Reports a status of "completed"
mPhotoTask.handleDecodeState(DECODE_STATE_COMPLETED);
...
}
...
}
...
PhotoTask类也拥有ImageView的引用。该ImageView用于展示Bitmap。虽然Bitmap和ImageView在相同的对象里都有引用。但你不能在该对象里直接将Bitmap的值赋给ImageView。因为该类并不运行在UI线程。接下来，发送状态码给PhoteTask对象。
Send status up the object hierarchy
PhotoTask维护着图片的引用，也持有显示这个图片的imageview的引用。他会PhotoDecodeRunnable接受一个状态码，再将它传递给创建了线程池和初始化了handler的对象：
public class PhotoTask {
...
// Gets a handle to the object that creates the thread pools
sPhotoManager = PhotoManager.getInstance();
...
public void handleDecodeState(int state) {
int outState;
// Converts the decode state to the overall state.
switch(state) {
case PhotoDecodeRunnable.DECODE_STATE_COMPLETED:
outState = PhotoManager.TASK_COMPLETE;
break;
...
}
...
// Calls the generalized state method
handleState(outState);
}
...
// Passes the state to PhotoManager
void handleState(int state) {
/*
* Passes a handle to this task and the
* current state to the class that created
* the thread pools
*/
sPhotoManager.handleState(this, state);
}
...
}
Move data to the UI
PhotoManager从PhotoTask接受状态码和PhotoTask对象的引用。因为该状态码TASK_COMPLETE，产生一个包含该状态码和任务对象的消息，然后发送该消息给Handler：
public class PhotoManager {
...
// Handle status messages from tasks
public void handleState(PhotoTask photoTask, int state) {
switch (state) {
...
// The task finished downloading and decoding the image
case TASK_COMPLETE:
/*
* Creates a message for the Handler
* with the state and the task object
*/
Message completeMessage =
mHandler.obtainMessage(state, photoTask);
completeMessage.sendToTarget();
break;
...
}
...
}
最后，Handler.handleMessage()检查每一个接受到的Message的状态码。如果状态码是TASK_COMPLETE，意味着任务结束。在Message里的PhotoTask对象也包含这Bitmap和ImageView对象。
这时，因为Handler.handleMessage()运行在主线程。你能放心的将Bitmap展示在ImageView上。
private PhotoManager() {
...
mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message inputMessage) {
// Gets the task from the incoming Message object.
PhotoTask photoTask = (PhotoTask) inputMessage.obj;
// Gets the ImageView for this task
PhotoView localView = photoTask.getPhotoView();
...
switch (inputMessage.what) {
...
// The decoding is done
case TASK_COMPLETE:
/*
* Moves the Bitmap from the task
* to the View
*/
localView.setImageBitmap(photoTask.getImage());
break;
...
default:
/*
* Pass along other messages from the UI
*/
super.handleMessage(inputMessage);
}
...
}
...
}
...
}
...
}