目录
前言
Handler使用，请参见：https://blog.csdn.net/fdsafwagdagadg6576/article/details/110293636
正文
一 整体框架
- 总体流程
- Handler通过sendMessage()发送Message到MessageQueue队列；
- Looper通过loop()，不断提取出达到触发条件的Message，并将Message交给target来处理；
- 经过dispatchMessage()后，交回给Handler的handleMessage()来进行相应地处理。
- 将Message加入MessageQueue时，往管道写入字符，可以会唤醒loop线程；
二 生产者消费者模型
| 模块 | 线程 |
| 生产者 | 子线程handler.sendmessage |
| 消费者 | 主线程 looper & handler.handlemessage |
| 中介 | 主线程 messageQueue |
三 线程同步
1） 主线程和子线程读写同步，是messageQueued.next 通过epoll监听messagequeue绑定的文件fd,实现读写同步.
2） 子线程之间写queue同步，是messageQueued.enqueueMessage中的锁.
四 角色作用
| 角色 | 作用 | 分层（activity入口--开发者使用--android系统层） |
| handler | 发送和处理消息 | 开发者使用接口. |
| looper | 每个线程只能有一个Looper。messageQueue属于它. | |
| 它的loop方法负责读取MessageQueue中的消息，读到消息后把消息发送给Handler进行处理。(线程和Looper绑定) | Activity入口函数创建&android 系统层使用 | |
| messagequeue | 先进先出的方式来管理msg.创建Looper对象时，会在它的构造方法中创建MessageQueue对象。(looper和messagequeue绑定) | android 系统层使用 |
| message | 消息 | 应用层 |
五 源码分析
0 生成者-消费者原理
两个关联(绑定),对象关联(绑定),消息和对象关联(绑定).
- 对象关联(绑定)：这个模型是用global queue全局变量通信，通过传入接收方的queue实现接收对象和发送对象绑定(建立关联).
- 消息和对象关联(绑定)：通常的作用是将对象放入线程，线程调用对象的函数和message执行。
handler模型是以消息为中心，将消息放入主线程，消息绑定了handler对象，进而调用了handler执行函数。实现了对象，消息和函数绑定.
handler.sendmessage(msg)--msg.target.handlemsg(msg).
改写成以对象为中心的实现call ladder:Looper.enqueuemessage(handler)---handler.handlemessage(handler.msg).
| 模型 | 模块关系 | 通信 | 同步 | 适用场景 | 消息流程 |
|---|---|---|---|---|---|
| cs | 主从 | socket | 阻塞 | 多进程 | client发送，server 接收处理，将结果返回client |
| 生产者-消费者 | 对等 | global queue | 锁（工作）+阻塞（空闲) | 多线程 | 线程1将对象传入线程2，线程2处理(线程2可以是线程池) |
Handler 模型分析：
1） 角色：handler，looper
2） 类层：handler类，Looper类，messageQueue类.
每个类的作用：
handler类：1) init 绑定looper，queue; 2) send msg 3) handle msg .
looper类：1） create queue 2) 循环读取 3） 分发
3） 消息流程：handler---messageQueue---Looper---hander,发送---接收---分发---处理.
4） 线程作用和同步
UI线程画界面，workthread处理业务逻辑。
线程同步机制
类图关系
1 Handler类
1.1 Handler 构造函数初始化
- 无参数构造函数
public class Handler { /**我们通常用于创建Handler的构造方法之一*/
public Handler() {
this(null, false);
}
//=============step1: 构造函数====================
public Handler(Callback callback, boolean async) { ...... //=======step2:获取Looper(messagequeue管理者)==============
mLooper = Looper.myLooper();
//=======step3: 获取Looper的Messagequeue=====
mQueue = mLooper.mQueue;
//回调函数默认是Null
mCallback = callback;
//设置消息是否为异步处理方式
mAsynchronous = async;
}
根据调用关系:
step1: Handler构造函数中会去创建一个Looper对象。handler和Looper绑定,同时绑定Looper的messageQueue。
step2: Looper.myLooper()获取Looper.
step3: mLooper.mQueue 获取Looper的MessageQueue.
- 有参构造函数
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
Handler类在构造方法中，可指定Looper，Callback回调方法以及消息的处理方式(同步或异步)，对于无参的handler，默认是当前线程的Looper。
mainHandler = new Handler() 等价于 new Handler（Looper.myLooper()）
Looper.myLooper()：获取当前进程的looper对象。详见下文.
1.2 Handler send message
call laddder:
sendEmptyMessage--sendEmptyMessageDelayed----sendMessageDelayed------sendMessageAtTime--------enqueueMessage/
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) { MessageQueue queue = mQueue;
......
return enqueueMessage(queue, msg, uptimeMillis);
}
// 最后调用此方法添加到消息队列中private boolean enqueueMessage(MessageQueue queue, Message msg,long uptimeMillis) {
msg.target = this;// 设置发送目标对象是Handler本身 ......
return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息队列中
}
step1: Message.obtain
step2：enqueueMessage(queue, msg, uptimeMillis)
step3: msg.target = this;// 设置发送目标对象是Handler本身
return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息队列中
1.3 消息处理
case1： handleMessage(msg);
是派生一个Hanlder子类并重写其handleMessage方法来处理具体的消息。
发送发是sendMessage.
case 2：handleCallback & mCallback.handleMessage(msg)
用callback来创建一个Handler的实例而无需派生Handler的子类。而Callback给我们提供了另外一种方式，那就是当我们不想派生子类的时候，可以通过Callback来实现.
call ladder:
post
--sendMessageDelayed
----getPostMessage
------m.callback = r//Runnable对象
--------new Handler(callback)
Message的callback是什么？其实就是一个Runnable对象，实际上就是Handler的post方法所传递的Runnable参数
private static void handleCallback(Message message) { message.callback.run();}
发送方：
public final boolean post(Runnable r){
sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
最后要注意的是写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop()才会中止，其后的代码才能得以运行。
1.4 异常处理
内存泄漏
//检查Handler是否是static的;如果不是的,那么有可能导致内存泄露
if (FIND_POTENTIAL_LEAKS) {
final Class klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName());
}
}
2 Looper类
2.1 创建MessageQueue
//Looper类的构造方法创建了消息队列MessageQueue对象private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}
一个线程一个Looper一个MessageQueue.
2.2 获取Looper对象
通过ThreadLocal获取Looper对象
//handler调用的获取Looper对象的方法。实际是在ThreadLocal中获取。 public static Looper myLooper() {
return sThreadLocal.get();
}
2.3 Looper 主循环
Looper 读取message & 分发message
//looper中最重要的方法loop()，该方法是个死循环，会不断去消息队列MessageQueue中获取消息，//然后调dispatchMessage(msg)方法去执行public static void loop() {
final Looper me = myLooper(); f
inal MessageQueue queue = me.mQueue;
//进入loop的主循环方法
for (;;) {
Message msg = queue.next(); // might block
......
//msg.target is handler；分发消息
msg.target.dispatchMessage(msg);
msg.recycle();
}
- Message msg= queue.next() ; 读取MessageQueue的下一条Message；
- msg.target.dispatchMessage(msg);把Message分发给相应的target；
next源码分析，参见MessageQueue类分析
下面是dispatchMessage分析
// 在looper类中的loop()方法内部调用的方法public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); }
分发给handleMessage 和handleCallback 处理.
2.4 子线程创建Looper（扩展）
默认是在主线程中创建Looper，子线程使用的是主线程Looper.
ThreadLocal中set Looper并保存到当前线程的TLS区域. 将线程和Looper绑定??
Looper创建的同时MessageQueue消息队列也被创建完成，Looper绑定MessageQueue对象。
//perpare()方法，用来初始化一个Looper对象
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) { ......
sThreadLocal.set(new Looper(quitAllowed));
}
在非主线程中直接new Handler() 会报如下的错误: Can't create handler inside thread that has not called Looper.prepare() 原因是非主线程中默认没有创建Looper对象，需要先调用Looper.prepare()启用Looper，然后再调用Looper.loop()。
子线程自己创建Looper
class childThread extends Thread{
public Handler mHandler;
@Override
public void run()
{
//子线程中必须先创建Looper
Looper.prepare();
mHandler =new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg); //处理消息
}
};
//启动looper循环
Looper.loop();
}
}
2.5 ThreadLocal
ThreadLocal机制：通常的全局变量，各个子线程是共享的。ThreadLocal变量特殊性是，它是global变量，但是每个子线程的ThreadLocal值是私有的.内部有个map管理每个线程和对应的变量.
ThreadLocal和线程局部变量又什么区别？ 线程局部变量完全可以替代ThreadLocal，但是ThreadLocal使用简单,java采用局部变量的方法比较少。两者的关系钱存在自己家和银行，实际是一样.
主线程和子线程都是，通过全局Looper类的threadlocal 机制创建looper. Threadlocal 一个looper类统一管理所有线程的looper.
Prepare创建，Looper.getlooper 获取. Looper类会根据所在线程自己正确判断返回该线程的looper.
三 MessageQueue类
next() :提取下一条message.在这里messagequeue 阻塞
Message next() {
final long ptr = mPtr;
......
for (;;) {
//阻塞操作，当等待nextPollTimeoutMillis时长，或者消息队列被唤醒，都会返回
nativePollOnce(ptr, nextPollTimeoutMillis);
......
}
}
messageQueue 从java-jni-native c++流程，参见：http://gityuan.com/2015/12/27/handler-message-native/
四 小结
知识点：生产者消费者模型.
一个线程一个Looper一个MessageQueue和多个handler框架.
多线程同步.