刚开始学习Android的时候，知道异步线程无法更新UI，于是找了个能把更新的动作抛给UI线程的东西，这个东西就是Handler。
一开始就只会在主线程也就是UI线程new一个Handler，之后在各个子线程里面使用，并没想过一些原理的东西，其实需要学习的知识还有很多。
一、线程之间的同步
A. 子线程向主线程发送消息，我们一开始学习的都是这种比较简单方式。
1、主线程中new Handler，并实现handleMessage方法
2、子线程中获得主线程Handler的实例
3、子线程向主线程发消息sendMessage
B. 主线程向子线程发送消息：
#点击按钮向mThread线程发送消息
mStartBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
......
mHandler.sendMessage(......);
}
});
mThread.start();
...... Thread mThread = new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
#实例化Handler，实现handleMessage
mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
......
}
};
Looper.loop();
}
});
通过这个我们比较直观的看见相同和不同的地方：
相同的地方：A线程向B线程发送消息，A需要拿到B实例化的Handler对象
不同的地方：子线程多了下面两个东西：
Looper.prepare();
.......
Looper.loop();
其实说不同的地方，只是A类型我们实现的时候不需要写Looper，理论上主线程一样需要有Looper，那么很容易想到，Android已经给我们写好了，后面有具体讲。
二、Looper,Handler,Message
Looper：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
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在创建的时候会初始化一个MessageQueue，这个是用来存储Message的管道
public static void loop() {
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
......
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
......
}
}
在loop的时候会循环的从MessageQueue取Message，然后分发Message。msg.target其实就是Handler，于是Handler就可以获得数据并进行处理。
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();
}
上面的还是比较有意思的，这里简单总结下：
- msg.callback不为空，执行msg.callback.run
- mCallback不为null,执行mCallback.handleMessage(msg)，可能会执行第3中情况
- 最后可能会执行Handler本身的handleMessage(msg)方法。
一般的是3这种情况，1发生在使用Handler在异步线程中直接更新UI的情况。
Thread mThread = new Thread(new Runnable() {
@Override
public void run() {
mHandler.post(new Runnable() {
@Override
public void run() {
textView.setText("xxxx");
}
});
}
});
其实mHandler.post也是发送了一个消息，然后把Runnable传给Message并处理。
总结下：
Looper其实就是创建一个循环获取消息并发送Handler的类。
Message其实就是一个数据存储的类，用于传输数据。
Handler就是进行发送和处理消息的类。
这三个配合起来一起用，才能构建了handler线程之间传递数据的机制。
问题一：上面所说的需要Looper，Handler,Message配合使用才能完成这个工作，那么我写子线程向主线程时怎么没看到主线程的Looper呢？
这个我们可以去看下Activity的源码，其实在ActivityThread里面已经写好了这个东西，所有我们不需要写了。
public static void main(String[] args) {
......
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
......
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
注意：写在Looper.loop();后面的代码是无法执行。