Android Handler 机制以及各方法所在线程原理分析

Handler 的定义及作用：

因为有的文章已经说得比较清楚了，就直接引用下。这里借鉴http://mobile.51cto.com/aprogram-442833.htm

一、Handler的定义：

主要接受子线程发送的数据， 并用此数据配合主线程更新UI。

解释：当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) ， 主线程为管理界面中的UI控件， 进行事件分发， 比如说， 你要是点击一个 Button ，Android会分发事件到Button上，来响应你的操作。  如果此时需要一个耗时的操作，例如: 联网读取数据，    或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象， 如果5秒钟还没有完成的话，会收到Android系统的一个错误提示  "强制关闭"。  这个时候我们需要把这些耗时的操作，放在一个子线程中，因为子线程涉及到UI更新，，Android主线程是线程不安全的，
也就是说，更新UI只能在主线程中更新，子线程中操作是危险的。 这个时候，Handler就出现了。，来解决这个复杂的问题 ，由于Handler运行在主线程中(UI线程中)，  它与子线程可以通过Message对象来传递数据， 这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据)  ， 把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点

handler可以分发Message对象和Runnable对象到主线程中， 每个Handler实例，都会绑定到创建他的线程中(一般是位于主线程)，它有两个作用：

(1)安排消息或Runnable 在某个主线程中某个地方执行；

(2)安排一个动作在不同的线程中执行。

Handler中分发消息的一些方法

post(Runnable)

postAtTime(Runnable，long)

postDelayed(Runnable long)

sendEmptyMessage(int)

sendMessage(Message)

sendMessageAtTime(Message，long)

sendMessageDelayed(Message，long)

以上post类方法允许你排列一个Runnable对象到主线程队列中，

sendMessage类方法， 允许你安排一个带数据的Message对象到队列中，等待更新。

（AtTime 和Delayed只是把handler传递时间进行确定，或者延迟一定时间。）

==========================================================

原创分割线

至于Message队列的相关知识，这里就不赘述了。接下来主要分析这些方法的线程关系。

可以看到参数方法主要分为两种，Message和Runnable

1.Message 类

简单来说Message类主要是在线程经过一系列计算后，需要更新一部分信息到UI上。

根据之前的说法，更新UI需要到主线程。而线程计算的结果就是使用Message来从子线程传递到主线程的。

用法:

如下面例子的msg.what是这条Message的唯一标志，在Handler的HandleMessage方法中识别出来后可以读取出其中set的Bundle 对象，然后进行UI更新

public class MainActivity extends AppCompatActivity {

private final int MESSAGE_ONE = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case MESSAGE_ONE:
Bundle bundle = msg.getData();
Toast.makeText(getApplicationContext(),bundle.getString("ToastMessage"),Toast.LENGTH_LONG).show();
}

Log.d("zhang556","thread4444: "+ Thread.currentThread().getId());
}
};
Log.d("zhang556","thread11111: "+ Thread.currentThread().getId());

new Thread(){
@Override
public void run() {
super.run();
Log.d("zhang556","thread3333: "+ Thread.currentThread().getId());
Message msg = new Message();
Bundle bundle = new Bundle();
bundle.putString("ToastMessage","I am Handler");
msg.what = MESSAGE_ONE;
msg.setData(bundle);
mHandler.sendMessage(msg);
}
}.start();

}
}

这里运行后Log如下

可以看到进行数据处理的线程和更新的线程并不是同一个，并且真机运行可以正常出现上面的Toast

接下来到源码看下Message做了什么

我这里并没有追的非常深，利用调用查看了下 Looper中（Looper是取消息的一个类）

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();
}
}

可以看到这里有个死循环取消息，并且最后使用

msg.target.dispatchMessage(msg);

进行分发。

接下来是走到这里

public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}这里的msg.callback 其实是一个Runnable对象。开始我们讲了有两种使用方法，一种使用message做参数，一种使用Runnable

没错，如果你调用的是message方法使用handler这里msg.callback 就为空（我到代码里看了确实是会把Runnable赋给msg.callback
，这里就不贴代码了）。所以这次是会回调我们的handleMessage，因此还是主线程调用的。

2.Runnable类

其实解释了刚才的dispatchMessage(Message msg)

大家也都应该知道了，Runnable作为一个对象来保存一些操作，但是实际没有开启线程，直接调用了

    private static void handleCallback(Message message) {

        message.callback.run();

    }

依然是回调的方法来执行你传过来的Runnable对象。下面还是一个Demo验证下Handler的post方法：

public class MainActivity extends AppCompatActivity {

private final int MESSAGE_ONE = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case MESSAGE_ONE:
Bundle bundle = msg.getData();
Toast.makeText(getApplicationContext(),bundle.getString("ToastMessage"),Toast.LENGTH_LONG).show();
}

Log.d("zhang556","thread4444: "+ Thread.currentThread().getId());
}
};
Log.d("zhang556","thread11111: "+ Thread.currentThread().getId());
mHandler.post(new Runnable() {
@Override
public void run() {
Log.d("zhang556","thread22222: "+ Thread.currentThread().getId());
}
});

// new Thread(){
// @Override
// public void run() {
// super.run();
// Log.d("zhang556","thread3333: "+ Thread.currentThread().getId());
// Message msg = new Message();
// Bundle bundle = new Bundle();
// bundle.putString("ToastMessage","I am Handler");
// msg.what = MESSAGE_ONE;
// msg.setData(bundle);
// mHandler.sendMessage(msg);
// }
// }.start();

}
}运行结果：

12-23 14:56:34.651 11460-11460/com.example.administrator.downloaddemo D/zhang556: thread11111: 1

12-23 14:56:34.722 11460-11460/com.example.administrator.downloaddemo D/zhang556: thread22222: 1

可以看到与主线程是同一线程，所以大家在进行异步操作的时候一定要使用handler传递message的这种方法。

而post一个runnable对象的方法，个人感觉是方便切换到主线程进行UI操作了。