在Android中，UI主线程并非线程安全的，所有UI相关的操作均需在UI主线程中完成。在默认情况下，开发者创建的Service、Activity、Broadcast均运行在UI主线程中，但将一些耗时操作，如网络下载、大文件读写、加解密计算、数据库操作等，也放在UI线程中执行，往往会阻塞UI线程，造成ANR异常，因此，在Android应用开发中，应特别注意线程的使用。
在Android中，实现多线程的方式有多种，开发者可以通过原生Java线程或Android对Java线程的封装即AsyncTask来实现多线程的效果。
为了开发出性能更好的应用，开发者必须对Android的多线程实现由清楚的了解，了解每种实现方式的优缺点和线程安全方面的问题，这样才能最大程度地发挥出Android的潜力。
1.Java线程实现
Android线程的实现本质上仍是Java线程，只是为了方便开发者进行实现，针对特定场景做了封装。本节将着重介绍基于Thread、Runnable的java线程的实现，并介绍Android的线程优先级。
（1）基于Thread的实现
基于Thread实现新线程和在Runnable构造器中实现新线程是传统Java实现线程的两种方式，基于Thread的实现非常简单。示例如下：
static class AThread extends Thread{
ActivityManagerService mService；
boolean mRead=false；
public AThread(){
super("ActivityManager");
}
public void run(){
Looper.prepare(); //初始化事件循环之后调用loop()
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_FOREGROUND):
android.os.Precess.setCanSelfBackground(false);
ActivityManagerService m=mew ActivityManagerService();
synchronized(this){
mSerice=m;
notifyAll();
}
synchronized(this){
while(!mReady){
try{
wait();
catch(InterruptedException e){
}
}
}
Looper.loop();
}
}
在Thread声明周期中，存在NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED等多个状态。线程的生命周期和状态迁移过程如下图：
下面是Thread中常用方法的说明，在实现Java线程时，务必掌握这些方法的用途。
getState() //获取线程的当前状态 interrupt() //中断当前线程
interrupted() //判断当前线程是否已中断 isAlive //判断线程是否仍在运行
isInterrupted() //判断是否处于“中断”状态 sleep() //线程睡眠指定的时间
join() //线程同步处理 run() //线程暂停一段时间
start() //开启线程 yield() //暂停当前线程，同优先级的其它线程获得时间片
（2）基于Runable的实现
对于APP开发来说，由于应用层本身的特点，Runnable使用更加广泛，下面是一个Runnable实现的示例：
private Runnable mForceCheckBoxRunnable =new Runnable(){
public void run(){
if(mCheckBoxPreference!=null){
mCheckBoxPreference.setChecked(!mCheckBoxPreference.isChecked());
}
mHandle.postDelayed(this, 1000);
}
};
另外，通过Handle的removeCallbacks()方法可以移除待运行的线程，通过postAtTime方法可以在特定时间将线程放入消息队列。
（3）线程优先级
Android线程优先级是以及Linux设置的，其优先级是用数字表示的，范围是-20~19，其中-20为最高优先级，19为最低优先级。优先级的设置通常用于处理并发线程产生的阻塞，防止重要性较低的线程占用大量的CPU资源。设置优先级的方法如下：
Process.setThreadPriority(priority);
根据适用场景的不同，Android提供了以下几种常用场景的线程优先级：
THREAD_PRIORITY_AUDIO //值为-16，用于音乐播放场景
THREAD_PRIORITY_BACKGROUND //值为10，用于普通后台程序
THREAD_PRIORITY_DEFAULT //值为0，默认优先级
THREAD_PRIORITY_DISPLAY //值为-4，用于普通显示线程
THREAD_PRIORITY_FOREGROUND //值为-2，用于普通前台程序
THREAD_PRIORITY_LESS_FAVORABLE //值为1，低于默认优先级
THREAD_PRIORITY_LOWEST //值为19，最低优先级
THREAD_PRIORITY_MORE_FAVORABLE //值为-1，最高默认优先级
THREAD_PRIORITY_URGENT_AUDIO //值为-19，重要的音频线程
THREAD_PRIORITY_UNGENT_DISPLAY //值为-8，重要的显示线程
2.Android线程封装
在Android中，为了简化开发者的工作，对Java线程进行了一定程度的封装，最主要的工作包括AsyncTask封装和接入UI线程。
（1）AsyncTask封装
AsyncTask通常用于后台线程和UI线程的交互。虽然AsyncTask本质上还是Thread加Handler的一个封装，但是由于采用了Java 1.5中的并发库FutureTask,故其在处理异步事务时表现卓越。使用AsyncTask的示例如下：
private class ReceicePushTask extends AsyncTask<Intent, Void, Void>{
protected Void doInBackground(Intent... instentd){
Intent intent-intents[0];
}
public void onReceive(Context context, Intent intent){}
}
AsyncTask中最基本的两个方法为doInBackground和onReceive，前者执行真正的后台计算，后者向UI主线程反馈计算结果。为了使用AsyncTask，开发者必须对AsyncTask进行继承。
AsyncTask的其他重要方法如下：
public final AsyncTask<Params, Progress,Result>execute(Params... params) //执行AsyncTask
public void onPostExecute(Result result) //在doInBackGround方法执行后执行，该方法在UI线程中执行
protected void onPreExecute() //在执行doInBackground方法前执行
protected final void publishProgress(Progress... values) //向UI线程反馈计算进度
public final boolean cancel(boolean mayInterruptIfRunning) //中断线程执行
public final boolean isCancelled() //判断AsyncTask是否已经被中断
在Android3.0中，Google又引入了execute(Runnable runnable)等多个方法。AsyncTask可以支持多个输入参数，甚至可变参数，其参数在execute方法中传入。
在中断开始执行时，系统将会调用AsyncTask的onCancelled方法，开发者可以在该方法中进行一些收尾工作，但是要注意，必须显式判断线程是否中断。假设在某个目录下寻找和关键字匹配的文件和文件夹，后台计算的工作被放置在AsyncTask中，显式判断线程是否中断的工作在dosth中进行，示例如下：
SearchTask mSearchTask=new SearchTask();
mSearchTask.execute(path) //执行线程
public void dosth(String value){
for(...){
if(mSearchTask.isCancelled()){
return;
}
}
}
下面是SearchTask的实现，其中包含了后台计算的入口、正常结束的入口、线程中断的入口等。
class SearchTask extends AsyncTask<String,Void, Void>{
public void doInBackground(String... value){
dosth(value[0]);
}
pretected void onCanceled(){
//执行中断的善后工作
}
protected void onPostExecute(Result result){ //该方法在UI线程执行
//执行正常的结束工作
}
}
（2）接入UI线程
在多线程编程中，执行后台计算的线程通常需要和UI线程进行交互，将计算的结果反馈给UI线程，呈现给用户，而传统的方法一般需要借组Handle。在Android中，充分考虑了开发者者方面的需要，从Activity、View和UI主线程3个层次提供了4种方式来接入UI线程。
1）Activity的runOnUiThread(Runnable)方法
Activity提供的接入UI线程的方法实际上是通过runOnUiThread(Runnable)方法进行的，从本质上讲，runOnUiThread方法时基于Handler的post(Runnable r)方法实现的。runOnUiThread(Runnable)的示例如下：
mActivity.runOnUiThread(new Runnable(){
public void run(){
mToast.setGravity(Gravity.BOTTOM, 0, 0);
mToast.show();
}
});
2)View的post(Runnable)方法
View的post(Runnable)方法从控件层面对多线程提供了支持，是开发更加灵活，其实现原理与基于Activity的runOnUiThread(Runnable)方法类似，均是借助Handle进行的。关于View的post(Runnable)方法的示例如下：
public void onClick(View v){
new Thread(new Runnable(){
public void run(){
finnal Bitmap bitmap=loadImageFromNetwork(http://example.com/image.png);
mImageView.post(new Runnable(){
public void run(){
mImageView.setImageBitmap(bitmap);
}
});
}
}).start
}
（3）View的postDelayed(Runnable, long)方法
View的postDelayed(Runnable, long)方法提供了延时处理的能力，示例如下：
final static int PAUSE_DELAY=100;
Runnable mRunnable=new Runnable(){
public void run(){
mView.postDelayed(mRunnable, PAUSE_DELAY);
}
};
（4）Handler方法
利用Message消息向UI主线程发送后台计算的消息，及时将计算结果反馈给实际用户，这一切均需要借助Handle进行消息处理。当UI线程接收到Message消息后，会调用其Handler进行消息处理。Handler处理消息的过程如下：
Message message=mHandle.obtainMessage(ORIENTATION_CHANGED)；
mHandler.sendMessage(message);
Handler mHandler=new Handler(){
public void handleMessage(Message msg){
switch(msg.what){
case ORIENTATION_CHANGED;
break;
}
}
};
3.线程间的消息通信
相比Thread加Handler的封装，Async更为可靠，更易于维护。AsyncTask的缺点是，一旦线程开启即dobackground方法执行后无法向线程发送消息，仅能通过预先设置好的标记来控制，当然可以通过挂起线程并等待标志位的改变来进行通信。
对于某些应用，原生的Thread加Handler以及Looper可能更灵活。下图揭示了三者之间的关系。
（1）消息队列
消息队列的维护是在线程中进行的，但默认除UI主线程外，其他线程并不拥有消息队列。为了维护一个消息队列，需要在线程中调用Looper的prepare方法进行初始化。为了使线程可以接收发送过来的消息，通常需要借组Handler来接收消息。一个维护消息队列的示例如下：
private class Queryrunner extends Thread{
public Handler mHandle
public void run(){
Looper.prepare(); //loop()方法应随后调用
mHandler=new Handler(){
public void handleMessage(Message msg){//处理收到的消息}
};
Looper.loop();
};
}
通过Looper还可以判断当前线程是否为UI主线程，方法如下：
private void assertUiThread(){
if(!Looper.getMainLooper().equals(Looper.myLooper())){
throw new RuntimeException("Not on the UI thread!");
}
}
通过查看Message的实现即可发现，Message继承于Parcelable，在消息的传递过程中，实际上传递的是序列化数据。Message的实现如下：
public final class message implements Parcelable{
public int what; //消息表示符
public int arg1; //传递参数
public int arg2; //传递对象
public Object obj; //传递的对象
public Messager replyTo;
long when;
Bundle data;
Handle target; //目标Handler
Runnable callback;
Message next;
private static final int MAX_POOL_SIZE=10;
...
}
通过分析Message的源代码实现可以发现，一个线程会自动维护一个消息池，该消息池的大小为10.在需要生成消息时，首先从消息池中获取消息，只有当消息池中的消息均被使用时，才会重新创建新消息，当消息使用结束时，消息池会回收消息。
从obtain方法的实现中可以看出，在发送消息时，通过obtain方法获得Message比创建Message的效率更高。发送消息的示例如下：
public void progress(boolean progress){
android.os.Message msg=android.os.Message.obtain();
msg.what=MSG_PROGRESS;
msg.arg1=progress ? 1: 0;
sendMessage(msg);
}
（2）消息分发
消息的分发和接收均与Handler密切相关，对于消息的分发，Android目前提供了两种消息类型，一种是post消息，一种是send消息。其中post消息会在为了某一时间加入消息队列，而send消息则会立即加入到消息队列。
1）send消息
分发一个简单的send消息的方法如下：
Messagemsg=mHandler.obtainMessage(KILL_APPLICATION_MSG);
msg.arg1=uid;
msg.arg2=0;
msg.obj=pkg;
mHandler.sendMessage(msg);
如果没有参数需要传递，那么可以发送仅携带消息表示符的空消息，方法如下：
mHandler.sendEnptyMessage(CANCEL_HEAVY_NOTIFICATION_MSG);
2）post消息
通过post消息可以实现类似循环计算的功能，方法如下：
mTicker = new Runnable(){
public void run(){
if(mTickerStopped) return;
mCalender.setTimeInMillis(System.currentTimeMillis());
setText(DateFormat(mFormat, mCalendar));
invalidate();
long now=SystemClock.uptimerMillis();
long next=now + (1000-now%1000);
mHandler.postAtTime(mTicker, next);
}
};
mTicker.run();
（3）消息接收
消息的接收相对简单，但是如果存在重入问题，应注意数据的同步。关于数据安全的内容。在Handler中消息接收的过程如下：
public void dispatchMessage(Message msg){
if(msg.callback !=null){
handleCallback(msg); //通过Message自身回调进行处理
}else{
if(mCallback.handleMessage(msg)){
return;
}
}
handleMessage(msg); //handle自己处理
}
对于消息队列而言，如何监听消息的来临呢，笔者的经验是，在Looper的loop方法中执行对消息的监听。loop方法的实现如下：
public static final void loop(){
Looper me=myLooper();
MessageQueue queue=me.mQueue;
Binder.clearCallingIdentity();
finnal long ident=Binder.clearCallingIdentity();
if(msg!=null){
if(msg.target==null){
return;
}
msg.target.dispatchMessage(msg); //调用Handler进行消息处理
msg.recycle(); //消息回收
}
}
4.线程安全处理
线程安全多是由多线程对共享资源的访问引起的，在线程安全层面，Android更多的是采用Java的实现，除了Java的join()、wait()、sleep()、notify()等安全方法和synchronized关键字外，还有Java的并发库。
除了synchronized关键字外，基于Java的多线程安全均比较复杂，对于不是十分复杂的场景，优先进行多线程处理。
（1）synchronized同步
在Android应用层，线程的并发很多是靠synchronized关键字来实现的，这样的实现非常简单。通过synchronized关键字，可以实现方法和语句块的同步。同步的本质是对特定的对象加锁，他们可以是来自调用方法的对象，也可以是开发者设计的对象。
另外，synchronized关键字并不能继承，对于父类的同步方法，在子类中必须再次显式声明才能成为同步方法。
synchronized关键字的局限在于在试图获得锁时无法设定超时和中断，每个锁只有一个条件，在某些场景下可能不够用。
另外，同步会带来较大的系统开销，甚至造成死锁，因此在进行开发时应避免无谓的同步。synchronize关键字可以实现方法同步和语句块同步。
1）方法同步
方法同步分一般方法同步和静态方法同步两种。一般方法同步的本质在于将synchronized关键字作用于对象引用（object referece)，作用域仅限类的单个对象，下面是AbsSeekBar中的一个实现：
public synchronized void setMax(int max){
super.setMax(max);
}
以上实现等同于如下实现：
public void setMax(int max){
synchronized(this){
super.setMax(max);
}
}
静态方法同步的本质是将类本身作为所，其作用域是该类的所有对象。下面是BitmapManaget中利用synchronized实现单子模式的过程。
private static BitmapManager sManager=null;
public static synchronized BitmapManaget instance(){
if(sManager==null){
sManager=new BitmapManager();
}
}
2）语句块的同步
方法同步的作用域较大，但事实上需要同步的范围可能并没那么大。当需要同步的范围不是很大时，可采用语句块同步。下面是AccelerometerListener中的一个示例：
private void setOrientation(int orientation){
synchronized(this){
}
}
将对象引用本身作为锁，显然影响并发效率，更灵巧的设计是自定义锁。自定义锁可以是任何类型的对象，但通常将其类型设计为Object。AbstractPreferences中的一个示例如下：
public abstract class AbstractPreferences extends Preferences
{
protected final Object lock;
protected AbstractPreferences getChild(String name) throws
BackingStoreException{
synchronized(lock){
}
}
}
采用自定义锁可以带来更高的并发效率，当然具体采用什么样的锁，需要根据实际场景决定。
（2）RPC通信
在基于AIDL的通信中，由于允许多个客户端的存在，其实现必须是线程安全的，开发者要注意，对于IPC调用方法，如果是一种耗时的操作，应避免在UI主线程中调用，以免阻塞UI主线程。
（3）SQLite调用
对于SQLite的调用，可能会存在多处执行读写操作的场景，这种场景也需要考虑线程的安全性。为了方便开发者操作,Android提供了类似于AsyncTask的AsyncQueryHandler方法来解决这一问题，将耗时的查询等操作放置在非UI主线程中，操作结束后，通过Handler调用相应的UI主线程的方法处理操作执行的结果，示例如下：
AsyncQueryHandler mAsyncQueryHandler=new AsyncQueryHandler(getContectResolver()){
protected void onQueryComplete(int token, Object cookie, Cursor cursor){
if(cursor!=null && cursor.moveToFirst()){
}
}
}
mAsyncQueryHandler.startQuery(0, null, mUri, new String[] {
MediaStore.Audio.Media.TITLE，MediaStore.Audio.Media.ARTIST
},MediaStore.Audio.Media,DATA+”=？“， new string[]{path}, null());