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操作了。

更多相关文章

随机推荐