一篇就够了系列之Handler全解析
前言：
两年前写过一篇Java中的多线程Thread Runnable及android的handler,现在想从源码角度好好分析下Handler及HandlerThread，毕竟Handler在Android开发和面试中都是涉及很多的知识点，所以很有必要全方位的了解透彻。
作用：
我们都知道在Android中，主线程（UI线程）需要高响应，不能做耗时操作（不然会出现ANR异常），所以一般的耗时的操作必须只能在子线程，比如在异步任务中进行网络请求，然后如何通知更新界面呢？这就是Handler的作用，即 在不同线程间进行通信
使用：
handler一般有两种使用方式
1 post方式
public class HandlerDemoActivity extends AppCompatActivity {
private Handler mHandler = new Handler();//Handler对象
private Runnable mRunnable;//在主线程中运行的Runnable对象
private TextView tv_show;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_demo);
tv_show= (TextView) findViewById(R.id.tv_show);
tv_show.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
doTask();
}
});
}
private void doTask() {
new Thread(new Runnable() {
@Override
public void run() {
Log.i("wy 1",Thread.currentThread().getName());
try {
Thread.sleep(5000);
mRunnable = new Runnable() {
@Override
public void run() {
tv_show.setText("5s");
Log.i("wy 2",Thread.currentThread().getName());
}
};
} catch (InterruptedException e) {
e.printStackTrace();
}
mHandler.post(mRunnable);
}
}).start();
}
}可以看到，Handler.post(Runnable)运行在子线程中，但是Runnable中的Run方法会运行在主线程中，所以可以在其中更新UI，也即实现了从子线程到主线程的信息传递。可以打印Log观察线程。
2 sendMessage方式
public class HandlerDemo2Activity extends AppCompatActivity {
private Handler mHandler =new Handler(){
//重写该方法，所有的send到的msg都会在该方法中处理，UI线程
@Override
public void handleMessage(Message msg) {
Log.i("wy 2",Thread.currentThread().getName());
switch (msg.what){
case 1:
tv_show.setText("5s");
break;
default:
break;
}
}
};
private TextView tv_show;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_demo);
tv_show= (TextView) findViewById(R.id.tv_show);
tv_show.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
doTask();
}
});
}
private void doTask() {
new Thread(new Runnable() {
@Override
public void run() {
Log.i("wy 1",Thread.currentThread().getName());
Message message=Message.obtain();
message.what=1;
mHandler.sendMessage(message);
}
}).start();
}
}可以看到，这种写法更加直观一些，在子线程中，通过handler调用sendMessage方法，然后在重写的HandlerMessage方法中进行处理，该方法是UI线程，自动实现了子线程和主线程的切换。
同时，post和sendMessage还有很多延伸出来的方法，原理类似，不做阐述了。
原理：
为什么Handler可以实现不同线程间的通信，内部的机制到底是如何实现的呢？带着这样的疑问，我们来看一张图片：
可以看到涉及到四个类，分别为：Looper，MessageQueue，Message和Handler
直观上它们的关系可以理解为：Handler发送消息Message到MessageQueue队列中，Looper在MessageQueue中取Message然后发送到Handler中进行处理。我们从源码角度分析一波
源码分析：
Looper：
看看该类的结构图：
可以发现，该类十分简单，6个属性，十几个方法，重要的不超过十个，Looper使用一般是调用prepare和loop方法，我们来看看其内部是如何：
1 prepare：
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));
}可以发现，prepare带参的方法中，sThreadLocal是用来保存创建的Looper对象，且判断保证了该对象的唯一性
2 构造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}构造方法生成一个MessageQueue对象和获得当前线程对象，此时，该Looper和MessageQueue有了关联
3 loop：
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;
// 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
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 {
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();
}
}loop方法可以分成两部分分析
1. 获取looper对象，MessageQueue对象，和一些简单判断
2. 一个for循环不断从MessageQueue中获取Message然后调用dispatchMessage分发出去。
剩下的其他prepareMainLooper，getMainLooper，myLooper，myQueue，isCurrentThread都是些简单的get，set方法，不作分析。该类是不是很简单呢？
Looper主要作用：
1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。
MessageQueue就是一个消息队列，更多的是add，get，remove作用，里面用到了很多native方法，不作分析
Handler：
我们从Handler的使用中一步步深入下去：
1 构造方法：
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
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());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}构造方法主要是获取了Looper，MessageQueue等对象，等一下，这里的Looper对象是那里生成的呢？实际上，因为实在主线程中，在Activity的启动类ActivityThread中，主动调用了prepare和loop方法，即Looper.prepareMainLooper()和Looper.loop();
2 sendMessage：
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;
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
一步步跟下去发现最终调用的是 enqueueMessage方法，其中
msg.target=this 将Handler对象赋值给了msg.target，Looper的loop方法中 msg.target.dispatchMessage(msg)就是在此时赋值的。
queue.enqueueMessage(msg, uptimeMillis)将msg加入到MessageQueue队列中了。
3 dispatchMessage：
loop中的dispatchMessage将消息分发：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}发现最终调用的就是handlerMessage，也就是我们需要重写的方法。
总结一下
1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。
2、Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。
3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。
4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。
5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。
3 post（Runnable）方式
代码一步一步跟下去，可以发现：
1.
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
2.
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
3.
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
。。。和上面一样，只是通过一个简单的转化，即将runnable对象赋值为message的callback属性，然后也是调用sendMessage方法，同时，我们可以发现，最终调用的dispatchMessage中：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}对callback的判断就是对于post方式的处理。可以称之为殊途同归！
HandlerThread：
我们都知道Handler是用来线程间进行通信的机制，一般我们使用的方式都是默认创建在主线程中，那么在子线程中如何使用呢？
使用：
1.创建一个HandlerThread，即创建了一个包含Looper的线程。
创建HandlerThread后一定要记得start()
HandlerThread handlerThread = new HandlerThread("xixiancheng");
handlerThread.start(); 2.获取HandlerThread的Looper
Looper looper = handlerThread.getLooper();3.建Handler，通过Looper初始化
将该子线程中的loop对象绑定到handler中，此时的handler就是该子线程的handler，可以在main中调用发送消息。
Handler handler = new Handler(looper);通过以上三步我们就成功创建HandlerThread。通过handler发送消息，就会在子线程中执行。
如果想让HandlerThread退出，则需要调用handlerThread.quit();。
此时可以实现不同线程之间进行消息的传递了。
源码分析：
1.
HandlerThread handlerThread = new HandlerThread("xixiancheng");
handlerThread.start(); 可以看到，HandlerThread是Thread类，我们来看其run方法：
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}Looper在该子线程中创建，所以当调用我们的new Handler（looper）方法时，该Handler也就在对应于该子线程中，HandlerThread源码中主要就是这个run方法，如果我们自己想在子线程中创建Handler对象也可以模仿其写法。我们熟知的IntentServie内部就是HandlerThread来实现的。
好了，关于Handler的使用知识点大概就这些了。欢迎阅读其他的文章：
一篇就够了系列之Android Manifest全解析
一篇就够了系列之ContentProvider全解析
一篇就够了系列之BroadcastReceiver全解析
一篇就够了系列之Service全解析
一篇就够了系列之Activity全解析