网站备案证件西安百度推广电话

1 前言

        Handler 即处理器，常用于跨线程通讯：线程A 和线程 B 拥有同一个 handler 对象，在线程 A 中使用 handler 的 sendMessage() 方法发送消息，在线程 B 中使用 handler 的 handleMessage() 方法处理消息。

        Handler 家族主要有：Message、Handler、MessageQueue、Looper。

（1）应用场景

• 子线程处理完耗时操作后，请求主线程更新 UI 
• 线程 A 定时给线程 B 发送消息
• 线程 A 周期性给线程 B 发送消息

（2）Handler 家族

• Message：消息类，通过 obtain() 方法可以生成一个 message 对象，每个 message 对象必须有一个 handler 对象；
• Handler：消息处理器，用于生成（obtainMessage）和处理消息（handleMessage）；
• MessageQueue：消息队列，用于存储消息，通过 enqueueMessage() 放入消息，next() 取出消息；
• Looper：循环器，用于取出消息，并通知 handler 执行消息。

（3）Handler 机制基本原理

        假设在线程 A 中创建了 handler 对象，重写了 handler 的 handleMessage() 方法，并且将 handler 对象传给了线程 B，则线程 B 和线程 A 间的通讯如下：

1.  生成消息：线程 B 通过 handler.obtainMessage() 生成消息（内部会调用 Message.abtain() 方法，并且会把当前 handler 传给 message 对象）；
2. 发送消息：线程 B 通过 handler.sendMessage() 发送消息，再调用 mQueue.enqueueMessage() 将消息放入消息队列；
3. 取出消息：线程A 中 mLooper 对象的 loop() 方法一直循环执行（若 mQueue 中没数据会等待），其内部会调用 mQueue 对象的 next() 方法，取出一个消息 msg；
4. 执行任务：线程 A 中取出的 msg 对象在创建时已绑定 handler，通过调用 msg.target.dispatchMessage() 方法，通知 handler 执行 handleMessage() 方法。

2 Handler 机制源码解析

2.1 Message

        （1）类图

        （2）生成消息

public static Message obtain() {synchronized (sPoolSync) {if (sPool != null) {Message m = sPool;sPool = m.next;m.next = null;m.flags = 0; // clear in-use flagsPoolSize--;return m;}}return new Message();
}public static Message obtain(Handler h) {Message m = obtain();m.target = h;return m;
}

        sPool 是可用的空消息对象池 ，其本质是链表，sPool 指向链表的头结点，next 指向下一个节点。

        （3）处理消息

msg.target.dispatchMessage(msg)//最终会执行如下一种
msg.callback.run()
handler.mCallback.handleMessage(msg)
handler.handleMessage(msg)

        target 是 Message 绑定的 handler 对象。 

2.2 Handler

        （1）类图

        （2）Looper 对象的获取

        若 handler 在主线程中创建，则不需要显式地给 handler 传递 Looper 对象。在主线程被创建时，系统会为主线程创建 Looper 对象，并开启消息循环。

public Handler() {this(null, false);
}public Handler(Handler.Callback callback, boolean async) {...mLooper = Looper.myLooper(); //获取与当前线程绑定的Looper对象...mQueue = mLooper.mQueue;...
}

        若 handler 在子线程中创建，则需要显示地传递 looper 对象，因为子线程在创建时不会创建 Looper 对象。

public Handler(Looper looper) {this(looper, null, false);
}public Handler(Looper looper, Handler.Callback callback, boolean async) {mLooper = looper;mQueue = looper.mQueue;...
}

         （3）生成消息

public final Message obtainMessage() {return Message.obtain(this);
}

        将 this 赋值给 message.target，与 message 对象绑定。

        （4）发送消息

public final boolean sendMessage(Message msg) {return sendMessageDelayed(msg, 0);
}public final boolean sendMessageDelayed(Message msg, long delayMillis) {if (delayMillis < 0) {delayMillis = 0;}return sendMessageAtTime(msg, SystemClock.uptimeMillis() + 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;if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);
}

        从 enqueueMessage() 方法中可以看到，在消息入队之前，将 this 赋值给了 msg，确保每个 msg 都能绑定一个 handler。

        （5）发送任务

public final boolean post(Runnable r) {return  sendMessageDelayed(getPostMessage(r), 0);
}private static Message getPostMessage(Runnable r) {Message m = Message.obtain();m.callback = r;return m;
}

        可以看到，即使发送的是 runnable，也会封装为 message。 

        （6）处理消息

public void dispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}
}private static void handleCallback(Message message) {message.callback.run();
}public void handleMessage(Message msg) {
}public interface Callback {public boolean handleMessage(Message msg);
}

        从 dispatchMessage()  方法中可以看到，处理消息的次序为：

1. msg.callback.run()
2. mCallback.handleMessage(msg)
3. handleMessage(msg)

2.3 MessageQueue

        （1）类图

        （2）存储消息

boolean enqueueMessage(Message msg, long when) {synchronized (this) {...Message p = mMessages;boolean needWake;if (p == null || when == 0 || when < p.when) {msg.next = p;mMessages = msg;needWake = mBlocked;} else {needWake = mBlocked && p.target == null && msg.isAsynchronous();Message prev;for (;;) { //根据消息时间，查找待插入位置prev = p;p = p.next;if (p == null || when < p.when) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p; //插入消息prev.next = msg;}if (needWake) {nativeWake(mPtr); //唤醒 looper}}return true;
}

        mMessages 是消息队列的链头。

        （3）取出消息

Message next() {...int nextPollTimeoutMillis = 0;for (;;) {...nativePollOnce(ptr, nextPollTimeoutMillis); //等待synchronized (this) {final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages;if (msg != null && msg.target == null) {do {prevMsg = msg;msg = msg.next;} while (msg != null && !msg.isAsynchronous());}if (msg != null) {if (now < msg.when) {nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);} else { //取出消息...if (prevMsg != null) {prevMsg.next = msg.next;} else {mMessages = msg.next;}msg.next = null;...return msg;}} ...}...}
}

2.4 Looper

        （1）类图

        （2）创建 Looper 对象

public static void prepare() {prepare(true);
}private static void prepare(boolean quitAllowed) {if (sThreadLocal.get() != null) {throw new RuntimeException("Only one Looper may be created per thread");}sThreadLocal.set(new Looper(quitAllowed)); //创建Looper对象，并与当前线程绑定
}

        （3）创建 MessageQueue

private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();
}

        （4）循环

public static void loop() {final Looper me = myLooper();...final MessageQueue queue = me.mQueue;...for (;;) {Message msg = queue.next(); //可能会等待...msg.target.dispatchMessage(msg); //处理消息...msg.recycleUnchecked(); //回收消息}
}

3 应用

3.1 应用一

        （1）主线程（处理消息）

Handler handler = new Handler() {@Overridepublic void handleMessage(Message msg) {System.out.println("打印消息");}
};

        （2）子线程（发送消息）

handler.sendEmptyMessage(0x111);

 3.2 应用二

        （1）主线程（处理消息）

Handler handler = new Handler();

        （2）子线程（发送消息）

handler.post(new Runnable() {@Overridepublic void run() {System.out.println("打印消息");}
});

4 拓展

        第3节中的案例都是子线程给主线程发送消息，但是某些场景需要主线程给子线程发送消息，或2个子线程间发送消息。默认情况下，系统会为主线程创建 Looper 对象，并开启消息循环，但新建的子线程中不会创建 Looper 对象，此时，就需要应用到 HandlerThread 类。

        （1）HandlerThread 类图

        （2）HandlerThread 核心源码

// 消息循环，通过threadHandler.start()开启循环
public void run() {mTid = Process.myTid();Looper.prepare(); //创建looper对象，并与当前线程绑定synchronized (this) {mLooper = Looper.myLooper();notifyAll();}Process.setThreadPriority(mPriority);onLooperPrepared();Looper.loop(); //消息循环mTid = -1;
}//获取handler，并注入mLooper
public Handler getThreadHandler() {if (mHandler == null) {mHandler = new Handler(getLooper());}return mHandler;
}

        （3）应用

        线程 A（处理消息）

HandlerThread handlerThread = new HandlerThread("A");
handlerThread.start();
//Handler handler = handlerThread.getThreadHandler();
Handler handler = new Handler(handlerThread.getLooper());

        线程 B（发送消息）

handler.post(new Runnable() {@Overridepublic void run() {System.out.println("打印消息");}
});