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

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()必須在對象上面調用）; 另外就是用於接收訊息時檢查訊息迴圈是否已經退出(如上例)。