Android開發_多線程詳解(九)

使用線程處理 耗時比較長的“業務” 

有以下幾種方式： 

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來實現的！