[size=medium][color=red][b] Android 的消息处理机制 -- Looper,Hander,Message[/b][/color][/size]
[size=small][color=olive][b]1、Android的消息处理有三个核心类:Lopper,Handler和Message; 另外还有个 Message Queue (消息队列) , 但MQ 被封装到了Looper 里面了,所以不会直接的和MQ打交道,因此不是核心的类;
2、线程的魔法师Looper:Looper 的字面意思是"循环者" ,被设计来使一个普通线程变成Lopper 线程。即循环工作的线程。循环线程,一个线程不断的循环,一旦有了新的任务则执行,执行完继续等待下一个任务,这就是Looper线程;
Looper 的加深理解:
A、Looper 线程就是循环工作的线程;
B、一个Thread只能有一个Looper对象,它是一个ThreadLocal;
C、一个线程可以有多个Handler,但是只能有一个Looper
3、如何创建一个Looper 线程:
[/b][/color][/size]
/**
* 创建一个循环线程
* @author Administrator
* 线程,继承了Thread
*/
public class LooperThread extends Thread {
public void run() {
// 将当前的线程初始化为Looper线程
Looper.prepare();
//......
// Looper 开始工作,调用loop() 方法,
// 不断的从自己的MQ中取出队头的消息(任务)执行
Looper.loop(); // 开始循环线程
}
}
[size=medium][color=red][b]通过以上的核心代码,当前的线程就可以升级为Looper线程了;[/b][/color][/size]
[size=small][color=olive][b]4、Looper 类的介绍:
除了prepare() 和 loop() 方法,Looper 类还提供了一些有用的方法:
Looper.myLooper(); // 得到当前线程Looper对象;
public static final Looper myLooper(){
// 在任意线程调用Looper.myLooper() 返回的都是那个线程的Looper
return (Looper)sThreadLocal.get();
}
getThread() 得到looper对象所属线程;
public Thread getThread(){
return mThread;
}
quit(); 方法结束looper循环;
public void quit(){
// 创建一个空的message, 它的target为null,表示结束循环消息
Message msg = Message.obtain();
//发出消息
mQueue.enqueueMessage(msg,0);
}
5、Looper的总结:
a、每个线程有且最多只能有一个Looper对象,它是一个ThreadLocal;
b、Looper内部有一个消息队列,loop() 方法调用后线程开始不断从队列中取出消息执行;
c、Looper使一个线程变成Looper线程;
6、Handler的理解:
异步处理大神,handler扮演了往MQ上添加消息和处理消息的角色(只处理由自己发出的消息),即通知MQ它要执行一个任务(sendMessage),并在loop到自己的时候执行该任务(handleMessage),整个过程是异步的。handler创建时会关联到一个looper,默认的构造方法将关联当前线程的looper,不过这也是可以set的;
温习提示: post发出的Runnable对象最后都被封装成了Message对象;
handleMessage(Message msg);为"钩子方法";
android 中的主线程也是一个looper线程;
7、Handler的用处:
A、可以在任意线程中发送消息,这些消息会被添加到关联的MQ上。
B、handler是在它关联的looper线程中处理消息的;
8、案例:线程之间进行消息的传递,主线程发消息给自己
注意:这里使用static修饰,因为在项目中便于单元测试,可以自行设计;[/b][/color][/size]
private static Handler handler; // 消息处理
/**
* 测试:主线程发消息给自己
*/
public static void toOwn() {
// 得到主线程的Looper对象
Looper looper = Looper.getMainLooper();
// 根据主线程的looper创建handler,所以这个handler发送的Message
// 会被传递给主线程的MessageQueue(消息队列)
handler = new Handler(looper) {
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.i("msg", "我是主线程,执行收到的消息:"+msg.obj.toString());
}
};
//
handler.removeMessages(0); // 移除
//提示:通过Message.obtain()来从消息池中获得空消息对象
// 以便节约资源
Message msg = handler.obtainMessage(1, 1, 1, "来自主线程的消息");
handler.sendMessage(msg); // 发送消息
}
/* ---------------- 主线程发消息给子线程 ------------------- */
/**
* 测试:主线程发消息给子线程
*/
public static void mainToChild(){
// 创建一个线程
thread = new Thread(new Runnable() {
// 线程任务
public void run() {
Log.i("msg", "子线程启动...");
Looper.prepare();// 创建该线程的Looper对象,用于接收消息
handler2_1 = new MyHandler(Looper.myLooper());
Log.i("msg", "对象创建完成");
Looper.loop();
}
});
thread.start(); // 启动线程
// 根据主线程的Looper对象创建Handler
handler2 = new Handler(Looper.getMainLooper()){
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.i("msg", "我是主线程的Handler,收到消息:"+msg.obj.toString());
// 此处 主线程可以将数据给子线程
handler2_1 = new MyHandler(Looper.myLooper());
Message msg2 = handler2_1.obtainMessage(1, 1, 1, "主传子");
handler2_1.sendMessage(msg2);
}
};
Message msg = handler2.obtainMessage(1, 1,1,"主线程进来了,开始分发数据");
handler2.sendMessage(msg); // 发送消息队列
}
[size=small][color=red][b] 子线程数据处理类:[/b][/color][/size]
public class MyHandler extends Handler {
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.i("msg","我是子线程,收到消息为:"+msg.obj.toString());
}
public MyHandler(Looper looper) {
super(looper);
}
}
[size=small][color=olive][i][b]
另外还有:子线程给主线程发送数据 , 子线程给子线程发送数据; 其实对于Looper的理解也很简单,Handler的对象如果是以主线程构建的则处理主线程的MQ ,如果以子线程Looper对象创建Handler对象,则为处理子线程的MQ消息队列;[/b][/i][/color][/size]