Android处理程序:Handler Looper Message源码研究

线程Thread的线程变量ThreadLocal中，存放着这个线程的looper;Looper在初始化时，会新建一个消息队列messageQueue，之后Looper进入一个死循环，等待从消息队列MessageQueue取得消息Message(Looper是消费者)，没有消息时会阻塞;

我们程序中的handler，会通过sendMessage或post方法，往MessageQueue中添加消息时，添加的这个Message，会记录他是属于哪个Handler发出的，同时根据message.when，决定新添加的这个Message在Queue中的位置，MessageQueue中只有一个当前的Message，队列关系是通过Message中的prev，next维护的，Message是一个链表的节点;

添加消息后，消费者Looper取得Message，并调用建立Message的Hander的dispatchMessage方法。

咋一看好像Handler即sendMessage，又handlerMessage，事情还是只有一个线程在做事情。

但是后来想想，明白了这样设计的必要性。

因为这个***的线程一般而言，都是mainUI线程，如果你有个可以分成多个小任务的任务要处理，你没有使用Handler，直接执行，也许系统忙于处理你这个任务，而无法及时响应用户事件，从而导致ANR的抛出。

如果你把你的任务拆成几个小任务，用Handler来实现，那么系统就可以把你的小任务推到后面来处理，抽出时间来响应用户操作。

如果真的有大任务，一般式需要另外线程去处理，或者开启Service。

一个在新线程中使用handler例子，我们来分析下源码

Java代码

 
 
 
  
  
  
new Thread(new Runnable() { 
  
  
  
@Override public void run() { 
  
  
  
Handler handler; 
  
  
  
//1、初始化Looper 
  
  
  
Looper.prepare(); 
  
  
  
//2、绑定handler到CustomThread实例的Looper对象、定义处理消息的方法 
  
  
  
handler= new Handler() { 
  
  
  
@Override public void handleMessage(Message msg) { 
  
  
  
} 
  
  
  
}; 
  
  
  
// 3、发送消息 
  
  
  
handler.sendMessage(new Message()); 
  
  
  
handler.post(new Runnable()) 
  
  
  
handler.obtainMessage(1, "hello").sendToTarget(); 
  
  
  
//4、启动消息循环 
  
  
  
Looper.loop(); 
  
  
  
} 
  
  
  
}).start(); 
 
 

1 Java代码

 
 
 
  
  
  
public static final void prepare() { 
  
  
  
if (sThreadLocal.get() != null) { // 每个线程，只能有一个Looper对象 
  
  
  
throw new RuntimeException("Only one Looper may be created per thread"); 
  
  
  
} 
  
  
  
// 如果当前线程没有Looper，新建一个，构造函数是private的 
  
  
  
sThreadLocal.set(new Looper()); 
  
  
  
} 
  
  
  
private Looper() { 
  
  
  
mQueue = new MessageQueue(); // 建立消息队列 
  
  
  
mRun = true; 
  
  
  
mThread = Thread.currentThread(); 
  
  
  
} 
 
 

2 Java代码

 
 
 
  
  
  
public Handler(){ 
  
  
  
mLooper = Looper.myLooper(); // 取得当前线程的Looper，如果抛异常 
  
  
  
if (mLooper == null) { 
  
  
  
throw new RuntimeException( 
  
  
  
"Can't create handler inside thread that has not called Looper.prepare()"); 
  
  
  
} 
  
  
  
mQueue = mLooper.mQueue; // 取得消息队列 
  
  
  
mCallback = null; 
  
  
  
} 
 
 

3 Java代码

 
 
 
  
  
  
//不管调用哪个方法，最终执行的是 
  
  
  
public boolean sendMessageAtTime(Message msg, long uptimeMillis){ 
  
  
  
boolean sent = false; 
  
  
  
// 取得消息队列 
  
  
  
MessageQueue queue = mQueue; 
  
  
  
if (queue != null) { 
  
  
  
msg.target = this; // 消息发出着是自己 
  
  
  
sent = queue.enqueueMessage(msg, uptimeMillis); // 添加到消息队列中 
  
  
  
} 
  
  
  
else { 
  
  
  
RuntimeException e = new RuntimeException( 
  
  
  
this + " sendMessageAtTime() called with no mQueue"); 
  
  
  
Log.w("Looper", e.getMessage(), e); 
  
  
  
} 
  
  
  
return sent; 
  
  
  
} 
  
  
  
final boolean enqueueMessage(Message msg, long when) { 
  
  
  
if (msg.when != 0) { 
  
  
  
throw new AndroidRuntimeException(msg 
  
  
  
+ " This message is already in use."); 
  
  
  
} 
  
  
  
if (msg.target == null && !mQuitAllowed) { 
  
  
  
throw new RuntimeException("Main thread not allowed to quit"); 
  
  
  
} 
  
  
  
synchronized (this) { 
  
  
  
if (mQuiting) { 
  
  
  
RuntimeException e = new RuntimeException( 
  
  
  
msg.target + " sending message to a Handler on a dead thread"); 
  
  
  
Log.w("MessageQueue", e.getMessage(), e); 
  
  
  
return false; 
  
  
  
} else if (msg.target == null) { 
  
  
  
mQuiting = true; 
  
  
  
} 
  
  
  
msg.when = when; 
  
  
  
Message p = mMessages; 
  
  
  
// 之前没有其他消息了，MessageQueue中当前消息mMessages 就是传递进来的msg 
  
  
  
if (p == null || when == 0 || when < p.when) {  
  
  
  
msg.next = p; 
  
  
  
mMessages = msg; 
  
  
  
this.notify(); // 唤醒  
  
  
  
} else {  
  
  
  
// 之前有其他消息了，将传递的msg放到适合的位置，根据when  
  
  
  
Message prev = null;  
  
  
  
while (p != null && p.when <= when) {  
  
  
  
prev = p;  
  
  
  
p = p.next;  
  
  
  
}  
  
  
  
msg.next = prev.next;  
  
  
  
prev.next = msg;  
  
  
  
this.notify(); // 唤醒  
  
  
  
}  
  
  
  
}  
  
  
  
return true;  
  
  
  
} 
 
 

4 Java代码

 
 
 
  
  
  
public static final void loop() { 
  
  
  
Looper me = myLooper(); 
  
  
  
MessageQueue queue = me.mQueue; 
  
  
  
while (true) { // 死循环 
  
  
  
Message msg = queue.next(); // 当队列中没有消息时会阻塞 
  
  
  
if (msg != null) { 
  
  
  
if (msg.target == null) { // 消息没有发送者时，退出消息循环 
  
  
  
// No target is a magic identifier for the quit message. 
  
  
  
return; 
  
  
  
} 
  
  
  
if (me.mLogging!= null) me.mLogging.println( 
  
  
  
">>>>> Dispatching to " + msg.target + " " 
  
  
  
+ msg.callback + ": " + msg.what 
  
  
  
); 
  
  
  
// 调用消息发出者的dispatchMessage，这里msg.target是我们sendMessage的handler 
  
  
  
msg.target.dispatchMessage(msg); 
  
  
  
if (me.mLogging!= null) me.mLogging.println( 
  
  
  
"<<<<< Finished to " + msg.target + " " 
  
  
  
+ msg.callback); 
  
  
  
msg.recycle(); 
  
  
  
} 
  
  
  
} 
  
  
  
} 
  
  
  
final Message next() { 
  
  
  
boolean tryIdle = true; 
  
  
  
while (true) { 
  
  
  
synchronized (this) { 
  
  
  
// 没有消息的或，会阻塞 
  
  
  
try { 
  
  
  
if (mMessages != null) { 
  
  
  
if (mMessages.when-now > 0) { 
  
  
  
Binder.flushPendingCommands(); 
  
  
  
this.wait(mMessages.when-now); 
  
  
  
} 
  
  
  
} else { 
  
  
  
Binder.flushPendingCommands(); 
  
  
  
this.wait(); 
  
  
  
} 
  
  
  
} 
  
  
  
catch (InterruptedException e) { 
  
  
  
} 
  
  
  
} 
  
  
  
} 
  
  
  
} 
 
 

总结

Handler作用：

1. 执行计划任务

2. 线程间通信

一个handler，只能接收到自己发出的message。handler实例与消息Message处理是关联的，发送和接受要匹配

Handler操作队列，主要是在子线程操作主线程的消息队列

Handler是实现异步的一种方式，用法是在主线程中建立Handler，(主线程中的Handler不用掉Looper.prepare);

在子线程(耗时操作)任务完成后sendMessage，这个Message会发送到主线程的消息队列中，主线程Handler的重写dispatchMessage方法，做新线程任务完成后的事情，大部分是更新UI。

本文题目：Android处理程序:Handler Looper Message源码研究
浏览路径：http://www.shufengxianlan.com/qtweb/news48/393648.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联