Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發實例 >> Android入門:深入學習理解 Handler HandlerThread AsyncQueryHandler 三者的關系

Android入門:深入學習理解 Handler HandlerThread AsyncQueryHandler 三者的關系

編輯：Android開發實例

首先創建工程 ThreadDemo 創建Activity

 

一、Handler

 

Handler在android裡負責發送和處理消息。它的主要用途有：

　　1）按計劃發送消息或執行某個Runnanble(使用POST方法)； 　　2）從其他線程中發送來的消息放入消息隊列中，避免線程沖突（常見於更新UI線程） 　　 默認情況下，Handler接受的是當前線程下的消息循環實例（使用Handler(Looper looper)、Handler(Looper  looper, Handler.Callback callback) 可以指定線程），同時一個消息隊列可以被當前線程中的多個對象進行分發、處理（在UI線程中，系統已經有一個Activity來處理了，你可以再起若干個 Handler來處理）。在實例化Handler的時候，Looper可以是任意線程的，只要有Handler的指針，任何線程也都可以 sendMessage。Handler對於Message的處理不是並發的。一個Looper 只有處理完一條Message才會讀取下一條，所以消息的處理是阻塞形式的（handleMessage()方法裡不應該有耗時操作，可以將耗時操作放在其他線程執行，操作完後發送Message（通過sendMessges方法）,然後由handleMessage()更新UI）。

 

 

  1. package com.debby.threaddemo;  
  2. import android.app.Activity;  
  3. import android.content.AsyncQueryHandler;  
  4. import android.os.Bundle;  
  5. import android.os.Handler;  
  6. import android.os.HandlerThread;  
  7. import android.util.Log;  
  8. public class ThreadDemo extends Activity {  
  9.     private static final String TAG = "bb";    
  10.     private int count = 0;    
  11.     private Handler mHandler ;    
  12.         
  13.     private Runnable mRunnable = new Runnable() {    
  14.             
  15.         public void run() {    
  16.             //為了方便 查看，我們用Log打印出來    
  17.             Log.e(TAG, Thread.currentThread().getId() + " " +count);    
  18.             count++;    
  19.             setTitle("" +count);    
  20.             //每2秒執行一次    
  21.             mHandler.postDelayed(mRunnable, 2000);    
  22.         }    
  23.             
  24.     };    
  25.     @Override    
  26.     public void onCreate(Bundle savedInstanceState) {    
  27.         Log.e(TAG, "Main id    "+Thread.currentThread().getId() + " " +count);    
  28.         super.onCreate(savedInstanceState);    
  29.         setContentView(R.layout.main);     
  30.         //通過Handler啟動線程    
  31.         mHandler =  new Handler();  
  32.         mHandler.post(mRunnable);    
  33.     }    
  34.     @Override    
  35.     protected void onDestroy() {    
  36.         //將線程與當前handler解除綁定  
  37.         //mHandler.removeCallbacks(mRunnable);    
  38.         super.onDestroy();    
  39.     }    
  40. } 


 

這裡直接通過Handler啟動一個線程

 

執行測試後可以發現 setTitle("" +count);   該行代碼可以執行 並可以不斷改變UI

 

由於android是單線程模型 所以可見個線程就是運行在UI主線程當中的 通過兩次打印的Log也可以看出是同一個線程

 

也就是說mHandler.post(mRunnable);  執行了run()方法 並沒有執行Thread的start()方法開啟一個新的線程

 

所以這種方式不適合比較耗時的操作 會堵塞主線程 UI message隊列

 

另外 mHandler.removeCallbacks(mRunnable);   該行代碼如果注釋掉會發現即使退出該Acitivity也會繼續執行線程的run()

方法 所以這裡需要注意

 

二、 HandlerThread

HandlerThread繼承於Thread，所以它本質就是個Thread。與普通Thread的差別就在於，它有個Looper成員變量。這個Looper其實就是對消息隊列以及隊列處理邏輯的封裝，簡單說就是 消息隊列+消息循環。

當我們需要一個工作者線程，而不是把它當作一次性消耗品，用過即廢棄的話，就可以使用它。

 

 

  1. public class ThreadDemo extends Activity {  
  2.     private static final String TAG = "bb";    
  3.     private int count = 0;    
  4.     private Handler mHandler ;    
  5.         
  6.     private Runnable mRunnable = new Runnable() {    
  7.             
  8.         public void run() {    
  9.             //為了方便 查看，我們用Log打印出來    
  10.             Log.e(TAG, Thread.currentThread().getId() + " " +count);    
  11.             count++;    
  12. //            setTitle("" +count);    
  13.             //每2秒執行一次    
  14.             mHandler.postDelayed(mRunnable, 2000);    
  15.         }    
  16.             
  17.     };    
  18.     @Override    
  19.     public void onCreate(Bundle savedInstanceState) {    
  20.         Log.e(TAG, "Main id    "+Thread.currentThread().getId() + " " +count);    
  21.         super.onCreate(savedInstanceState);    
  22.         setContentView(R.layout.main);     
  23.         //通過Handler啟動線程    
  24.         HandlerThread handlerThread = new HandlerThread("threadone");  
  25.         handlerThread.start();  
  26.         mHandler =  new Handler(handlerThread.getLooper());  
  27.         mHandler.post(mRunnable);    
  28.           
  29.           
  30.     }    
  31.     @Override    
  32.     protected void onDestroy() {    
  33.         //將線程與當前handler解除  
  34.         mHandler.removeCallbacks(mRunnable);    
  35.         super.onDestroy();    
  36.     }    
  37. } 

 

這裡通過HandlerThread啟動一個新線程

 

注這裡需要handlerThread.start();先啟動線程 才能 handlerThread.getLooper() 獲取當前線程的Looper

 

通過HandlerThread的run方法可以發現

 

  1. public void run() {  
  2.         mTid = Process.myTid();  
  3.         Looper.prepare();  
  4.         synchronized (this) {  
  5.             mLooper = Looper.myLooper();  
  6.             Process.setThreadPriority(mPriority);  
  7.             notifyAll();  
  8.         }  
  9.         onLooperPrepared();  
  10.         Looper.loop();  
  11.         mTid = -1;  
  12.     } 

 

這裡調用了Looper.prepare(); 初始化了Looper

 

通過執行可以發現 setTitle("" +count);  在這裡調用會出現異常

 

還有通過打印的日志

 

 

都可以發現 這裡啟動的是一個新線程 雖然不能直接操作UI 但可以通過Message發送消息來進行操作

 

這樣可以處理一些比較耗時操作

 

三、AsyncQueryHandler

 

這個類繼承了Handler 實現了 ContentProvider處理相關的一些操作的異步方式

 

與其說這個類提供給我們一個處理ContentProvider的方法 我覺得這更給我們提供了一個處理異步的方案

 

若我們不用AsyncQueryHandler，直接在UI 線程調用ContentResolve去操作數據庫比如查詢，若你的數據庫的數據很少還好，若很多，就會出現ANR了。一般解決ANR,就是開 thread去解決。讓UI線程知道何時查詢完畢，可以更新UI將查詢的結果表現出來

 

首先分析一下 AsyncQueryHandler 這個類

 

他的基本策略如下：
　　1. 當你實例化一個AsyncQueryHandler類時（包括其子類...），它會單件構造一個線程WorkerHandler，這個線程裡面會構建一個消息循環。
　　2. 獲得該消息循環的指針，用它做參數實例化另一個Handler類，該類為內部類。至此，就有了兩個線程，各自有一個Handler來處理消息。
　　3. 當調用onXXX的時候，在XXX函數內部會將請求封裝成一個內部的參數類，將其作為消息的參數，將此消息發送至另一個線程。
　　4. 在該線程的Handler中，接受該消息，並分析傳入的參數，用初始化時傳入的ContentResolver進行XXX操作，並返回Cursor或其他返回值。
　　5. 構造一個消息，將上述返回值以及其他相關內容綁定在該消息上，發送回主線程。
　　6. 主線程默認的AsyncQueryHandler類的handleMessage方法（可自定義，但由於都是內部類，基本沒有意義...）會分析該消息，並轉發給對應的onXXXComplete方法。
　　7. 用戶重寫的onXXXComplete方法開始工作。

 

通過上面的HandlerThread的用法可以看到我們啟動新線程進行操作的代碼是很冗余很繁瑣的 把更多對Handler的操作暴露出來了

這樣是很不利於維護和復用的（雖然有時候沒有必要 這不顯得比較NB嘛）

 

那通過這個類我們只需要實例化的時候傳入ContentResolver 並實現自己的回調方法onXXXComplete 最後調用你需要的操作就可以

 

確實代碼簡潔了 想知道怎麼回事去反編譯android的代碼去吧

 

那我覺得如果有什麼非ContentProvider操作，卻需要異步多線程執行的話，模擬一套，是個不錯的選擇

 

這裡我做了個demo

  1. public class AsyncWorkHandler extends Handler{  
  2.       
  3.     private static final String TAG = "bb";  
  4.       
  5.     private static Looper sLooper = null;  
  6.       
  7.     private static final int EVENT_ARG_WORK = 1;  
  8.       
  9.     private WorkerHandler mWorkerHanler ;  
  10.       
  11.     protected final class WorkerArgs{  
  12.         Handler handler;  
  13.     }  
  14.       
  15.     public AsyncWorkHandler(){  
  16.         synchronized (AsyncQueryHandler.class) {  
  17.             if (sLooper == null) {  
  18.                 HandlerThread thread = new HandlerThread("AsyncWorkHandler");  
  19.                 thread.start();  
  20.                 sLooper = thread.getLooper();  
  21.             }  
  22.         }  
  23.         mWorkerHanler = new WorkerHandler(sLooper);  
  24.     }  
  25.       
  26.     protected class WorkerHandler extends Handler {  
  27.         public WorkerHandler(Looper looper) {  
  28.             super(looper);  
  29.         }  
  30.         @Override 
  31.         public void handleMessage(Message msg) {  
  32.               
  33.             WorkerArgs args = (WorkerArgs) msg.obj;  
  34.               
  35.             int info = msg.arg1;  
  36.               
  37.             Log.i(TAG, "worker handler=-------------------"+info);  
  38.               
  39.             Message result = args.handler.obtainMessage();  
  40.               
  41.             result.arg1 = EVENT_ARG_WORK;  
  42.               
  43.             result.sendToTarget();  
  44.         }  
  45.           
  46.     }  
  47.       
  48.     /**  
  49.      * 需要重寫的回調函數  
  50.      */ 
  51.     protected void onCompleteWork(){  
  52.           
  53.     }  
  54.       
  55.     public void doWork(int strInfo){  
  56.           
  57.         Message msg = mWorkerHanler.obtainMessage();  
  58.           
  59.         WorkerArgs workArgs = new WorkerArgs();  
  60.         workArgs.handler = this;  
  61.         msg.obj = workArgs;  
  62.         msg.arg1 = strInfo;  
  63.         mWorkerHanler.sendMessage(msg);  
  64.     }  
  65.       
  66.     @Override 
  67.     public void handleMessage(Message msg) {  
  68.           
  69.         Log.i(TAG, "main handler ----------------"+msg.arg1);  
  70.           
  71.         if(EVENT_ARG_WORK == msg.arg1){  
  72.             onCompleteWork();  
  73.         }  
  74.     }  
  75. } 

 

就是仿照這個類而已 當然這個還需要根據實際的情況進行一些封裝 實際內部還是通過HandlerThread來實現

 

比較耗時的操作可以在WorkerHandler的 方法中進行實現

 

那調用的方法

  1. AsyncWorkHandler asyncWorkHandler = new AsyncWorkHandler(){  
  2.             @Override 
  3.             protected void onCompleteWork() {  
  4.                 Log.i("bb", "do call back methoid");  
  5.             }  
  6.         };  
  7.         asyncWorkHandler.doWork(321); 

 

比較簡單點了  這個可以用在一個項目中比較經常會用到的地方

我想我們做地圖用來處理數據的部分可以考慮嘗試一下 ~~

  1. 上一頁:
  2. 下一頁:
Android開發實例
Android編程入門Android技術基礎Android資訊關於Android編程Android開發Android開發環境Android開發實例
相關文章
熱門文章
Android提高之ListView實現自適應表格的方法 Android百度地圖之定位SDK（v3.1）使用示例（二） 接入新浪、騰訊微博和人人網的Android客戶端實例 Android本地化 android系統在靜音模式下關閉camera拍照聲音的方法 android通過藍牙接收文件打開時無法自動選擇合適的應用程序
Android登錄實例

登錄應用程序的屏幕，詢問憑據登錄到一些特定的應用。可能需要登錄到Face
基於Android設計模式之

策略模式其實特別簡單（聽到這句話，大家是不是心裡一下子放松了？）
Android MediaPlayer(多媒體播放)

Android提供了許多方法來控制播放的音頻/視頻文件和流。其中該方法是
Android MediaPlayer(多媒體播放)

Android提供了許多方法來控制播放的音頻/視頻文件和流。其中該方法是
閱讀排行版
Copyright © Android教程網 All Rights Reserved