Android開發筆記之:訊息迴圈與Looper的詳解

NO IMAGE

Understanding Looper
Looper是用於給一個執行緒新增一個訊息佇列(MessageQueue),並且迴圈等待,當有訊息時會喚起執行緒來處理訊息的一個工具,直到執行緒結束為止。通常情況下不會用到Looper,因為對於Activity,Service等系統元件,Frameworks已經為我們初始化好了執行緒(俗稱的UI執行緒或主執行緒),在其內含有一個Looper,和由Looper建立的訊息佇列,所以主執行緒會一直執行,處理使用者事件,直到某些事件(BACK)退出。
如果,我們需要新建一個執行緒,並且這個執行緒要能夠迴圈處理其他執行緒發來的訊息事件,或者需要長期與其他執行緒進行復雜的互動,這時就需要用到Looper來給執行緒建立訊息佇列。
使用Looper也非常的簡單,它的方法比較少,最主要的有四個:
    public static prepare();
    public static myLooper();
    public static loop();
    public void quit();
使用方法如下:
1. 在每個執行緒的run()方法中的最開始呼叫Looper.prepare(),這是為執行緒初始化訊息佇列。
2. 之後呼叫Looper.myLooper()獲取此Looper物件的引用。這不是必須的,但是如果你需要儲存Looper物件的話,一定要在prepare()之後,否則呼叫在此物件上的方法不一定有效果,如looper.quit()就不會退出。
3. 在run()方法中新增Handler來處理訊息
4. 新增Looper.loop()呼叫,這是讓執行緒的訊息佇列開始執行,可以接收訊息了。
5. 在想要退出訊息迴圈時,呼叫Looper.quit()注意,這個方法是要在物件上面呼叫,很明顯,用物件的意思就是要退出具體哪個Looper。如果run()中無其他操作,執行緒也將終止執行。
下面來看一個例項
例項
這個例子實現了一個執行任務的服務:
複製程式碼 程式碼如下:
public class LooperDemoActivity extends Activity {
    private WorkerThread mWorkerThread;
    private TextView mStatusLine;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle icicle) {
 super.onCreate(icicle);
 setContentView(R.layout.looper_demo_activity);
 mMainHandler = new Handler() {
     @Override
     public void handleMessage(Message msg) {
  String text = (String) msg.obj;
  if (TextUtils.isEmpty(text)) {
      return;
  }
  mStatusLine.setText(text);
     }
 };

 mWorkerThread = new WorkerThread();
 final Button action = (Button) findViewById(R.id.looper_demo_action);
 action.setOnClickListener(new View.OnClickListener() {
     public void onClick(View v) {
  mWorkerThread.executeTask(“please do me a favor”);
     }
 });
 final Button end = (Button) findViewById(R.id.looper_demo_quit);
 end.setOnClickListener(new View.OnClickListener() {
     public void onClick(View v) {
  mWorkerThread.exit();
     }
 });
 mStatusLine = (TextView) findViewById(R.id.looper_demo_displayer);
 mStatusLine.setText(“Press ‘do me a favor’ to execute a task, press ‘end of service’ to stop looper thread”);
    }

    @Override
    public void onDestroy() {
 super.onDestroy();
 mWorkerThread.exit();
 mWorkerThread = null;
    }

    private class WorkerThread extends Thread {
 protected static final String TAG = “WorkerThread”;
 private Handler mHandler;
 private Looper mLooper;

 public WorkerThread() {
     start();
 }

 public void run() {
     // Attention: if you obtain looper before Looper#prepare(), you can still use the looper
     // to process message even after you call Looper#quit(), which means the looper does not
     //really quit.
     Looper.prepare();
     // So we should call Looper#myLooper() after Looper#prepare(). Anyway, we should put all stuff between Looper#prepare()
     // and Looper#loop().
     // In this case, you will receive “Handler{4051e4a0} sending message to a Handler on a dead thread
     // 05-09 08:37:52.118: W/MessageQueue(436): java.lang.RuntimeException: Handler{4051e4a0} sending message
     // to a Handler on a dead thread”, when try to send a message to a looper which Looper#quit() had called,
     // because the thread attaching the Looper and Handler dies once Looper#quit() gets called.
     mLooper = Looper.myLooper();
     // either new Handler() and new Handler(mLooper) will work
     mHandler = new Handler(mLooper) {
  @Override
  public void handleMessage(Message msg) {
      /*
       * Attention: object Message is not reusable, you must obtain a new one for each time you want to use it.
       * Otherwise you got “android.util.AndroidRuntimeException: { what=1000 when=-15ms obj=it is my please
       * to serve you, please be patient to wait!…….. } This message is already in use.”
       */
//      Message newMsg = Message.obtain();
      StringBuilder sb = new StringBuilder();
      sb.append(“it is my please to serve you, please be patient to wait!\n”);
      Log.e(TAG, “workerthread, it is my please to serve you, please be patient to wait!”);
      for (int i = 1; i < 100; i ) {
   sb.append(“.”);
   Message newMsg = Message.obtain();
   newMsg.obj = sb.toString();
   mMainHandler.sendMessage(newMsg);
   Log.e(TAG, “workthread, working” sb.toString());
   SystemClock.sleep(100);
      }
      Log.e(TAG, “workerthread, your work is done.”);
      sb.append(“\nyour work is done”);
      Message newMsg = Message.obtain();
      newMsg.obj = sb.toString();
      mMainHandler.sendMessage(newMsg);
  }
     };
     Looper.loop();
 }

 public void exit() {
     if (mLooper != null) {
  mLooper.quit();
  mLooper = null;
     }
 }

 // This method returns immediately, it just push an Message into Thread’s MessageQueue.
 // You can also call this method continuously, the task will be executed one by one in the
 // order of which they are pushed into MessageQueue(they are called).
 public void executeTask(String text) {
     if (mLooper == null || mHandler == null) {
  Message msg = Message.obtain();
  msg.obj = “Sorry man, it is out of service”;
  mMainHandler.sendMessage(msg);
  return;
     }
     Message msg = Message.obtain();
     msg.obj = text;
     mHandler.sendMessage(msg);
 }
    }
}

這個例項中,主執行緒中執行任務僅是給服務執行緒發一個訊息同時把相關資料傳過去,資料會打包成訊息物件(Message),然後放到服務執行緒的訊息佇列中,主執行緒的呼叫返回,此過程很快,所以不會阻塞主執行緒。服務執行緒每當有訊息進入訊息佇列後就會被喚醒從佇列中取出訊息,然後執行任務。服務執行緒可以接收任意數量的任務,也即主執行緒可以不停的傳送訊息給服務執行緒,這些訊息都會被放進訊息佇列中,服務執行緒會一個接著一個的執行它們—-直到所有的任務都完成(訊息佇列為空,已無其他訊息),服務執行緒會再次進入休眠狀態—-直到有新的訊息到來。
如果想要終止服務執行緒,在mLooper物件上呼叫quit(),就會退出訊息迴圈,因為執行緒無其他操作,所以整個執行緒也會終止。
需要注意的是當一個執行緒的訊息迴圈已經退出後,不能再給其傳送訊息,否則會有異常丟擲”RuntimeException: Handler{4051e4a0} sending message to a Handler on a dead thread”。所以,建議在Looper.prepare()後,呼叫Looper.myLooper()來獲取對此Looper的引用,一來是用於終止(quit()必須在物件上面呼叫); 另外就是用於接收訊息時檢查訊息迴圈是否已經退出(如上例)。

您可能感興趣的文章:

Android開發中Looper.prepare()和Looper.loop()Android訊息處理機制Looper和Handler詳解Android中的Looper物件詳細介紹android開發教程之使用looper處理訊息佇列android的訊息處理機制(圖文 原始碼分析)—Looper/Handler/MessageAndroid 執行緒之自定義帶訊息迴圈Looper的例項