这是我参与「第四届青训营 」笔记创作活动的的第3天
通信组件
一、消息机制--Handler
1.消息机制的简介
Android的消息机制也是Handler机制，主要的作用是用来在不同线程之间的通信，通常使用在子线程执行完成一些耗时操作，需要回到主线程更新界面UI时,通过Handler将有关UI的操作切换到主线程。
如下是一个简单示例
public class Activity extends android.app.Activity {
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
System.out.println(msg.what);
}
};
@Override
public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onCreate(savedInstanceState, persistentState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
...............耗时操作
Message message = Message.obtain();
message.what = 1;
mHandler.sendMessage(message);
}
}).start();
}
}
2.消息机制包含三大部分
消息机制主要包含：MessageQueue，Handler和Looper这三大部分，以及 Message
Message：需要传递的消息，可以传递数据；
Looper
Looper的字面意思是“循环者”，它被设计用来使一个普通线程变成Looper线程 。所谓Looper线程就是执行循环工作的线程,不断循环执行(Looper.loop)，从MessageQueue中读取消息，按分发机制 将消息分发给目标处理者。
Looper的创建（Looper.prepare()）
在应用程序的入口ActivityThread.main()方法中系统已经帮我们创建好Looper对象
//主线程中不需要自己创建Looper
public static void main(String[] args) {
......
Looper.prepareMainLooper();
//为主线程创建Looper，该方法内部又调用 Looper.prepare()
......
Looper.loop();//开启消息轮询
......
}
子线程中的Looper是需要我们自己手动创建的
public class LooperThread extends Thread {
@Override
public void run() {
// 将当前线程初始化为Looper线程
Looper.prepare();
// ...其他处理，如实例化handler
// 开始循环处理消息队列
Looper.loop();
}
}
在Looper的构造方法中还创建了MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
- 无论是主线程还是子线程，Looper只能被创建一次，即一个Thread只有一个Looper。
- 所创建的Looper会保存在ThreadLocal（线程本地存储区）中，它不是线程，作用是帮助Handler获得当前线程的Looper。(ThreadLocal可以在不同的线程之中互不干扰地存储并提供数据，通过ThreadLocal可以轻松获取每个线程的Looper)
loop()进入循环模式，不断重复下面的操作，直到消息为空时退出循环:
读取MessageQueue的下一条Message； 把Message分发给相应的target。
当next() 取出下一条消息时，队列中已经没有消息时，next()会无限循环，产生阻 塞。等待MessageQueue中加入消息，然后重新唤醒。
public static void loop() {
final Looper me = myLooper();//得到当前线程Looper
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//获取Looper对象中的消息队列
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 开始循环
for (;;) {
Message msg = queue.next(); // might block 从MQ中取出消息,可能会阻塞,因为next()方法可能会无限循环
if (msg == null) {//消息为空，则退出循环
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
// 将真正的处理工作交给message的target(handler)处理分发消息
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();
}
}
Handler
消息辅助类，主要功能向消息池发送各种消息事件 (Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；
创建Handler
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
.................................
//必须先执行Looper.prepare()，才能获取Looper对象，否则为null.
mLooper = Looper.myLooper(); //从当前线程的TLS中获取Looper对象
if (mLooper == null) {
throw new RuntimeException("");
}
mQueue = mLooper.mQueue; //消息队列，来自Looper对象
mCallback = callback; //回调方法
mAsynchronous = async; //设置消息是否为异步处理方式
}
对于Handler的无参构造方法，默认采用当前线程TLS中的Looper对象，并且 callback回调方法为null，且消息为同步处理方式。只要执行 的 Looper.prepare() 方法，那么便可以获取有效的Looper对象。
在子线程中通过Handler的post()方式或send()方式发送消息，最终都是调用 了 sendMessageAtTime() 方法。
post方法
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, longuptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
send方法
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
就连子线程中调用Activity中的runOnUiThread()中更新UI，其实也是发送消息通知 主线程更新UI，最终也会调用 sendMessageAtTime() 方法。
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}
sendMessageAtTime()`方法的作用很简单，就是调用MessageQueue的 enqueueMessage()方法，往消息队列中添加一个消息。
MessageQueue
消息队列，但是它的内部实现并不是用的队列，实际上是通过一 个单链表的数据结构来维护消息列表，因为单链表在插入和删除上比较有优势。主 要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息 (MessageQueue.next)；
3.消息机制的运行流程
- 应用程序启动的时候，在主线程中会默认调用了 Looper.preper()方法，初始化Looper对象并绑定到当前线程中，并在Looper内部维护一个MessageQueue
- 接着调用handler.sendMessage()发送消息，会通过MessageQueue.enqueueMessage()向MessageQueue中添加一条消息
- 主线程调用Looper.looper()开启循环，不断轮询消息队列，通过MessageQueue.next()取出消息
- 取出的message不为空则调用msg.target.dispatchMessage()传递分发消息，目标handler收到消息后会执行handler.handlerMessage()方法处理消息
流程图：
MessageQueue，Handler和Looper三者之间的关系：
每个线程中只能存在一个 Looper，Looper是保存在ThreadLocal中的。主线程（UI线程）已经创建了一个 Looper，所以在主线程中不需要再创建Looper，但是在其他线程中需要创建 Looper。每个线程中可以有多个Handler，即一个Looper可以处理来自多个Handler 的消息。 Looper中维护一个MessageQueue，来维护消息队列，消息队列中的 Message可以来自不同的Handler。
