Looper、Handler应用---实现主线程向子线程发送消息

准备知识：

Looper类： 为一个线程开启一个消息循环，里面有一个消息队列，新线程是没有开启消息循环的，所以需要用到Looper的方法创建消息循环（主线程除外，主线程会自动为其创建Looper对象，开启消息循环）， MessageQueue存放消息和事件

 

Handler类： 辅助类，向绑定的Looper投递消息

 

Looper原型：

Looper.prepare()

Looper.loop

Looper.quit

代码：

[java] view plain copy

1. package com.test.looper;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.os.Handler;  
6. import android.os.Looper;  
7. import android.os.Message;  
8. import android.util.Log;  
9.   
10. public class MainActivity extends Activity {  
11.     private LooperThread  looperThread;  
12.   
13.     @Override  
14.     public void onCreate(Bundle savedInstanceState) {  
15.         super.onCreate(savedInstanceState);  
16.         setContentView(R.layout.main);  
17.         looperThread = new LooperThread();  
18.         looperThread.start();  
19.         looperThread.getHandler().sendEmptyMessage(1);  
20.     }  
21.       
22.       
23.     class LooperThread extends Thread {  
24.         private Handler mHandler;  
25.         private final Object mSync = new Object();  
26.   
27.         public void run() {  
28.             Looper.prepare();  
29.             synchronized (mSync) {  
30.                 mHandler = new Handler(){  
31.                     @Override  
32.                     public void handleMessage(Message msg) {  
33.                         Log.d("CYQ", "--->" + msg);  
34.                     }  
35.                 };  
36.                 mSync.notifyAll();  
37.             }  
38.             Looper.loop();  
39.         }  
40.           
41.         public Handler getHandler() {  
42.             synchronized (mSync) {  
43.                 if (mHandler == null) {  
44.                     try {  
45.                         mSync.wait();  
46.                     } catch (InterruptedException e) {  
47.                     }  
48.                 }  
49.                 return mHandler;  
50.             }  
51.         }  
52.         public void exit() {  
53.             getHandler().post(new Runnable(){  
54.                 public void run() {  
55.                     Looper.myLooper().quit();  
56.                 }});  
57.         }  
58.     }  
59. }  

注意一下几点：

1、new Handler()必须在子线程的run方法中，否则不是子线程的Handler

2、在getHandler方法中，我加入了同步，防止线程start了，但是并没有run结束，若此时直接返回mHandler会是一个null（不行可以试试，我一开始郁闷许久，最后在源码中发现有更稳定的实现，所以效仿了，

后记：

看来源码还是写得很健壮的，仍需多加学习！

总结一下（也许不对，请怀疑）：

一个线程有一个对应的Looper，这个Looper就是消息循环，我理解就是提供了一个消息循环的场所，但是消息的投递，消息的处理它不做，它会绑定一个Handler，然后Handler去投递和处理消息，一个线程中实现handleMessage，另外一个线程就可以sendMessage，线程可以主或者子，进而实现线程间消息的传递。