使用線程處理 耗時比較長的“業務”
有以下幾種方式：
1)Activity.runOnUiThread(Runnable)
2)View.post(Runnable) ;View.postDelay(Runnable , long)
3)Handler
4)AsyncTask
Android是單線程模型，這意味著Android UI操作並不是線程安全的並且這些操作必須在UI線程中執行，所以你單純的new一個Thread並且start()是不行的，因為這違背瞭Android的單線程模型。那麼如何用好多線程呢？總結一下：
事件處理的原則：所有可能耗時的操作都放到其他線程去處理。
Android中的Main線程的事件處理不能太耗時，否則後續的事件無法在5秒內得到響應，就會彈出ANR對話框。那麼哪些方法會在 Main線程執行呢？
1） Activity的生命周期方法，例如：onCreate（）、onStart（）、onResume（）等
2） 事件處理方法，例如onClick（）、onItemClick()等
通常Android基類中以on開頭的方法是在Main線程被回調的。
提高應用的響應性，可以從這兩方面入手。
一般來說，Activity的onCreate（）、onStart（）、onResume（）方法的執行時間決定瞭你的應用首頁打開的時間，這裡要盡量把不必要的操作放到其他線程去處理，如果仍然很耗時，可以使用SplashScreen。使用SplashScreen最好用動態的，這樣用戶知道你的應用沒有死掉。
當用戶與你的應用交互時，事件處理方法的執行快慢決定瞭應用的響應性是否良好，一般分為同步和異步兩種情況：
1） 同步，需要等待返回結果。例如用戶點擊瞭註冊按鈕，需要等待服務端返回結果，那麼需要有一個進度條來提示用戶你的程序正在運行沒有死掉。一般與服務端交互的都要有進度條，例如系統自帶的瀏覽器，URL跳轉時會有進度條。
2） 異步，不需要等待返回結果。例如微博中的收藏功能，點擊完收藏按鈕後是否成功執行完成後告訴我就行瞭，我不想等它，這裡最好實現為異步的。
無論同步異步，事件處理都可能比較耗時，那麼需要放到其他線程中處理，等處理完成後，再通知界面刷新。
這裡有一點要註意，不是所有的界面刷新行為都需要放到Main線程處理，例如TextView的setText（）方法需要在Main線程中，否則會拋出CalledFromWrongThreadException，而ProgressBar的setProgress（）方法則不需要在Main線程中處理。
當然你也可以把所有UI組件相關行為都放到Main線程中處理，沒有問題。可以減輕你的思考負擔，但你最好瞭解他們之間的差別，掌握事物之間細微差別的是專傢。把事件處理代碼放到其他線程中處理，如果處理的結果需要刷新界面，那麼需要線程間通訊的方法來實現在其他線程中發消息給Main線程處理。
如何實現線程間通訊
在Android中有多種方法可以實現其他線程與Main線程通訊，我們這裡介紹常見的兩種。
1） 使用AsyncTask
AsyncTask是Android框架提供的異步處理的輔助類，它可以實現耗時操作在其他線程執行，而處理結果在Main線程執行，對於開發者而言，它屏蔽掉瞭多線程和後面要講的Handler的概念。你不瞭解怎麼處理線程間通訊也沒有關系，AsyncTask體貼的幫你做好瞭。使用他你會發現你的代碼很容易被理解，因為他們都有一些具有特定職責的方法，尤其是AsyncTask，有預處理的方法onPreExecute，有後臺執行任務的方法doInBackground，有更新進度的方法publishProgress，有返回結果的方法onPostExecute等等，這就不像post這些方法，把所有的操作都寫在一個Runnable裡。不過封裝越好越高級的API，對初級程序員反而越不利，就是你不瞭解它的原理。當你需要面對更加復雜的情況，而高級API無法完成得很好時，你就杯具瞭。所以，我們也要掌握功能更強大，更自由的與Main線程通訊的方法：Handler的使用。
2） 使用Handler
這裡需要瞭解Android SDK提供的幾個線程間通訊的類。
2.1 Handler
Handler在android裡負責發送和處理消息，通過它可以實現其他線程與Main線程之間的消息通訊。
2.2 Looper
Looper負責管理線程的消息隊列和消息循環
2.3 Message
Message是線程間通訊的消息載體。兩個碼頭之間運輸貨物，Message充當集裝箱的功能，裡面可以存放任何你想要傳遞的消息。
2.4 MessageQueue
MessageQueue是消息隊列，先進先出，它的作用是保存有待線程處理的消息。
它們四者之間的關系是，在其他線程中調用Handler.sendMsg（）方法（參數是Message對象），將需要Main線程處理的事件添加到Main線程的MessageQueue中，Main線程通過MainLooper從消息隊列中取出Handler發過來的這個消息時，會回調Handler的handlerMessage（）方法。
除瞭以上兩種常用方法之外，還有幾種比較簡單的方法
3） Activity.runOnUiThread（Runnable）
4） View.post（Runnable）
View.postDelayed（Runnable， long）
5） Handler.post
Handler.postDelayed（Runnable， long）
利用線程池提高性能
這裡我們建議使用線程池來管理臨時的Thread對象，從而達到提高應用程序性能的目的。
線程池是資源池在線程應用中的一個實例。瞭解線程池之前我們首先要瞭解一下資源池的概念。在JAVA中，創建和銷毀對象是比較消耗資源的。我們如果在應用中需要頻繁創建銷毀某個類型的對象實例，這樣會產生很多臨時對象，當失去引用的臨時對象較多時，虛擬機會進行垃圾回收（GC），CPU在進行GC時會導致應用程序的運行得不到相應，從而導致應用的響應性降低。
資源池就是用來解決這個問題，當你需要使用對象時，從資源池來獲取，資源池負責維護對象的生命周期。
瞭解瞭資源池，就很好理解線程池瞭，線程池就是存放對象類型都是線程的資源池。
我增加瞭如何在其他線程中創建Handler的例子作為選學，前面都掌握好瞭的同學可以看一下，如果你需要實現一個跟Main線程類似的消息處理機制，需要其他線程可以跟你的線程通訊，可以通過這種方法實現。
1、問題提出
1）為何需要多線程？
2）多線程如何實現？
3）多線程機制的核心是啥？
4）到底有多少種實現方式？
2、問題分析
1）究其為啥需要多線程的本質就是異步處理，直觀一點說就是不要讓用戶感覺到“很卡”。
eg:你點擊按鈕下載一首歌，接著該按鈕一直處於按下狀態，那麼用戶體驗就很差。
2）多線程實現方式implements Runnable 或 extends Thread
3）多線程核心機制是Handler
4）提供如下幾種實現方式
Handler
————————————說明1
創建一個Handler時一定要關聯一個Looper實例，默認構造方法Handler()，它是關聯當前Thread的Looper。
eg:
我們在UI Thread中創建一個Handler,那麼此時就關聯瞭UI Thread的Looper！
這一點從源碼中可以看出！
精簡代碼如下：
public Handler() {
mLooper = Looper.myLooper();
//當前線程的Looper，在Activity創建時，UI線程已經創建瞭Looper對象
//在Handler中機制中Looper是最為核心的，它一直處於循環讀MessageQueue，有
//要處理的Message就將Message發送給當前的Handler實例來處理
if (mLooper == null) {
throw new RuntimeException(
"Can’t create handler inside thread that has not called Looper.prepare()");
}
//從以上可以看出，一個Handler實例必須關聯一個Looper對象，否則出錯
mQueue = mLooper.mQueue;
//Handler的MessageQueue，它是FIFO的嗎？不是！我感覺應該是按時間先後排列
//的！Message與MessageQueue到底是啥關系？感興趣可以研究一下源碼！
mCallback = null;
}
在創建一個Handler的時候也可以指定Looper，此時的Looper對象，可以是當前線程的也可以是其它線程的！
Handler隻是處理它所關聯的Looper中的MessageQueue中的Message，至於它哪個線程的Looper，Handler並不是很關心！
eg:
我們在UI線程中創建瞭Handler實例，此時傳進Worker線程的Looper，此時依然可以進行業務操作！
eg:
——————–創建工作者線程
private static final class Worker implements Runnable
{
private static final Object mLock = new Object() ;
private Looper mLooper ;
public Worker(String name)
{
final Thread thread = new Thread(null,this,name) ;
thread.setPriority(Thread.MIN_PRIORITY) ;
thread.start() ;
synchronized(mLock)
{
while(mLooper == null)
{
try
{
mLock.wait() ;
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
@Override
public void run() {
synchronized(mLock)
{
//該方法隻能執行一次,一個Thread隻能關聯一個Looper
Looper.prepare() ;
mLooper = Looper.myLooper() ;
mLock.notifyAll() ;
}
Looper.loop() ;
}
public Looper getLooper()
{
return mLooper ;
}
public void quit()
{
mLooper.quit() ;
}
}
我們可以在UI線程中創建一個Handler同時傳入Worker的Looper
eg:
—————-定義自己的Handler
private final class MyHandler extends Handler
{
private long id ;
public MyHandler(Looper looper)
{
super(looper) ;
}
@Override
public void handleMessage(Message msg) {
switch(msg.what)
{
case 100 :
mTv.setText("" + id) ;
break ;
}
}
}
———在Activity中創建Handler
this.mWorker = new Worker("workerThread") ;
this.mMyHandler = new MyHandler(this.mWorker.getLooper()) ;
———創建Message
final Message msg = this.mMyHandler.obtainMessage(100);
msg.put("test" , "test") ;
msg.sendToTarget() ;
需要註意的是，每一個Message都必須要有自己的Target即Handler實例！
源碼如下：
public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}
public static Message obtain(Handler h, int what) {
Message m = obtain();
m.target = h;//可以看出message關聯瞭當前的Handler
m.what = what;
return m;
}
以上隻是作瞭一點原理性的說明！
我們平時使用Handler主要是用來處理多線程的異步交互問題！
由於Android規定隻有UI線程才能更新用戶界面和接受用戶的按鈕及觸摸事件！
那麼就必須保證UI線程不可以被阻塞，從而耗時操作必須要開啟一個新的線程來處理！
那麼問題就來瞭，等耗時操作結束以後，如何把最新的數據反饋給用戶呢？而我們目前工作Worker線程中，從而不可以進行UI更新。
那麼怎麼辦呢？必須要把最新的數據傳給UI線程能處理的地方！現在就派到Handler出場瞭！可Handler到底幹瞭啥呢？簡要說明如下：
Activity所在的UI線程在創建的時候，就關聯瞭Looper和MessageQueue，那麼我們又在UI線程裡創建瞭自己的Handler，那麼Handler是屬於UI線程的，從而它是可以和UI線程交互的！
UI線程的Looper一直在進行Loop操作MessageQueue讀取符合要求的Message給屬於它的target即Handler來處理！所以啊，我們隻要在Worker線程中將最新的數據放到Handler所關聯的Looper的MessageQueue中，然而Looper一直在loop操作，一旦有符合要求的Message，就第一時間將Message交給該Message的target即Handler來處理！所以啊，我們在創建Message的時候就應該指定它的target即Handler！
但我們也可以，new Message() — > mHandler.sendMessage(msg) ;這是特例！
如果我們通過obtainMessage()方法獲取Message對象，此時Handler就會自動設置Message的target。可以看源碼！
簡單一點說就是：
UI線程或Worker線程提供MessageQueue，Handler向其中填Message，Looper從其中讀Message，然後交由Message自己的target即Handler來處理！！最終被從屬於UI線程的Handler的handlMessag(Message msg)方法被調用！！
這就是Android多線程異步處理最為核心的地方！！
有點羅嗦啊！！
*******************************************************************
在UI線程中創建Handler[一般繼承HandleMessage(Message msg)]
|
|
Looper可以屬於UI線程或Worker線程
|
|
從屬於Looper的MessgeQueue，Looper一直在loop()操作,在loop()中執行msg.target.dispatchMessage(msg);調用Handler的handleMessage(Message msg)
|
|
在 Worker線程中獲取Message，然後通過Handler傳入MessageQueue
*******************************************************************
—————–在創建一個Looper時，就創建瞭從屬於該Looper的MessageQueue
private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}
—-2—–View
post(Runnable action)
postDelay(Runnable action , long miliseconds)
—–3—–Activity
runOnUiThread(Runnable action)
該方法實現很簡單：
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
//如果當前線程不是UI線程
mHandler.post(action);
} else {
action.run();
}
}
其中：
mUiThread = Thread.currentThread() ;
mHandler = new Handler()
—–4—–AsyncTask<Params,Progress,Result>
Params,Progress,Result都是數據類型，
Params要處理的數據的類型
Progress處理進度的類型
Result處理後返回的結果
它是一個異步處理的簡單方法！
方法的執行順序：
1）
onPreExecute() –在UI線程中執行，作一些初始化操作
2）
doInBackground(Params… params) –在Worker線程中執行，進行耗時的後臺處理，在該方法中可以調用publishProgress(Progress progress) 進行進度處理
3）
onProgressUpdate(Progress progress) –在UI線程中執行，進行進度實時處理
4）onPostExecute(Result result) –在UI線程中執行， 在doInBackground(Params … params)返回後調用
5）
onCancelled() –在UI線程中執行，在AsyncTask實例調用cancle(true)方法後執行，作一些清理操作
幾點註意：
AsyncTask必須在UI線程中創建，
asyncTask.execute(Params… params) ;在UI線程中執行，且隻能執行一次
要想再次調用execute(Params… params)，必須重新創建AsyncTask對象
後3種方法本質上都是利用Handler來實現的！