1. Handler流程
1>：获取到消息，即就是数据之后调用handler.sendMessage()
public class MainActivity extends AppCompatActivity {
private TextView tv_text;
/**
* 直接在主线程中 new Handler
*/
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
String handlerMsg = (String)msg.obj ;
tv_text.setText(handlerMsg);
}
} ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv_text = (TextView) findViewById(R.id.tv_text);
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message1 = Message.obtain() ;
message1.obj = "Handler Test" ;
mHandler.sendMessage(message1) ;
Message message2 = Message.obtain() ;
mHandler.sendMessageDelayed(message2 , 1000) ;
Message message3 = Message.obtain() ;
mHandler.sendMessageDelayed(message3 , 500) ;
}
}).start();
}
}
2>：
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
3>：
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
4>：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
5>：MessageQueue中的enqueueMessage()方法，部分代码如下：
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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; // invariant: p == prev.next
prev.next = msg;
}
上边就是调用 handler.sendMessage()的流程，可以不用看上边的，直接从下边开始看；
1>：获取到消息，即就是数据之后调用handler.sendMessage() -> sendMessageDelayed() -> MessageQueue.enqueueMessage()
到目前为止，没有看到handler调用 handleMessage()方法，目前只是看到了MessageQueue，MessageQueue是一个消息队列，sendMessage()只是把消息加到了队列中，并没有执行
总结：
handler.sendMessage()只是把我们的 Message加入了MessageQueue消息队列，队列采用的是链表的方式，按照 when ，也就是时间排序，然后再也没有做其他事情，如下图所示：
2. Looper消息循环？
一般在主线程中 new Handler，就像上边的MainActivity代码，不会报错，但是如果在 子线程中使用Handler，必须调用 Looper.prepare()，否则会报下边错误，为什么主线程中不报错，子线程就报错，为什么？
因为在启动应用的时候，也就是在ActivityThread的入口方法main()方法已经帮我们写了Looper.prepareMainLooper()和Looper.loop()；
Looper.prepareMainLooper()：准备循环；
Looper.loop()：循环
分析：Looper.prepareMainLooper()：
下边主要来看这行代码：
sThreadLocal.set(new Looper(quitAllowed));
点击set()方法，进入到ThreadLocal的set()方法，如下：
public void set(T value) {
Thread t = Thread.currentThread();
// 从线程中获取 ThreadLocalMap，一个线程只有一个 ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
上边代码总结
- 其实就是创建一个Looper对象，并且保证一个Thread线程中只有一个 Looper对象；
- 一个线程只有一个ThreadLocal，也就是ThreadLocalMap；
分析Looper.loop()：
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
// 获取线程的 Looper对象，只有一个，是因为要保证队列只有一个
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 获取队列
final MessageQueue queue = me.mQueue;
for (;;) {
// 死循环，不断的获取消息队列中的消息
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
try {
// target就是handler，通过 handler 去执行Message，这个时候就调用了 handleMessage()方法，
// 而handleMessage()里边什么都没干，就是我们实现的handleMessage
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
// 回收消息
msg.recycleUnchecked();
}
}
1>：获取线程中的 Looper对象，只有一个，是因为要保证队列只有一个；
2>：然后获取消息队列MessageQueue，有一个for死循环，不断的获取消息队列中的消息；
3>：绑定target，这个target就是handler，通过handler去执行Message，这个时候就调用了handleMessage()方法，而handleMessage()方法里边什么也没干，就是我们实现的handleMessage()方法；
2. 为什么用Message.obtain()而不用 new Message()？
因为Message.obtain()可以直接拿一个可以回收的消息，用一下就可以了，用完之后可以回收，就不用 new Message对象，不用开辟内存；
3. ThreadLocal如何保证一个线程只有一个Looper对象？
由上边ThreadLocal中的set()方法可知，即就是这段代码：
public void set(T value) {
Thread t = Thread.currentThread();
// 从线程中获取 ThreadLocalMap，一个线程只有一个 ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
1>：它首先会获取当前线程，然后获取ThreadLocalMap，一个线程中只有一个ThreadLocalMap；
2>：然后根据this获取value，this是ThreadLocal，是静态的，源码如下，永远都是获取的一个Looper对象，如果不用一个线程绑定一个Looper，就会出问题，下图就是防止数据进行脏读，因为thread1线程不可能访问到 main线程的，因为一个线程只有一个循环器；
static final ThreadLocal sThreadLocal = new ThreadLocal();
4. Handler流程总结
1>：自己调用handler.sendMessage()方法，不断的给MessageQueue发送消息；
2>：主线程中的Looper不断的从MessageQueue中取消息；
3>：上边源码可以知道，通过绑定的 target，target就是handler，就会不断的调用handleMessage()方法处理消息；
4>：因为Looper是在主线程中，只要是通过handler发送消息到MessageQueue消息队列，所有的消息都会在主线程中去执行，达到了通过handler来对UI的更新；
5. MessageQueue消息队列为什么采用链表形式存储Message？
6. 链表和数组区别？
- 链表增删快，因为链表是散乱的，每个都有元素都有一个next，如下图所示，比如我想要在2和3之间插入6，可以让2的next指向6，6的next指向3就可以；
-
数组查询快，因为数组有角标，比如我需要找第3个元素，直接根据 角标2查找就可以，但是如果想要插入元素，比如我想要在2和3之间插入5，就比较麻烦，需要把3和4往后边移动，留出一个位置，然后把5放进去才行，比较麻烦；
如下图所示：
栈结构和链表结构.png