Android Handler 机制原理

Handler 概述

在Android系统中实现了一套类似的消息处理机制。在下面介绍handler机制前，首先得了解以下几个概念：
1. Message
消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
2. Message Queue
消息队列，用来存放通过Handler发布的消息，按照先进先出执行。
3. Handler
Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
4. Looper
循环器，扮演Message Queue和Handler之间桥梁的角色，循环取出Message Queue里面的Message，并交付给相应的Handler进行处理。
5. 线程
UI thread 通常就是main thread，而Android启动程序时会替它建立一个Message Queue。

Handler的定义

handler是Android给我们提供来更新UI的一套机制,也是一套消息处理机制
android在设计的时候封装了一套消息创建、传递、处理机制

Handler使用方法

1，传递Message,用于接收子线程发送的数据，并用此数据配合主线程更新UI

1.void handleMessage( Message msg):处理消息的方法，该方法通常被重写。
2.final boolean hasMessage(int what):检查消息队列中是否包含有what属性为指定值的消息
3.final boolean hasMessage(int what ,Object object) :检查消息队列中是否包含有what好object属性指定值的消息
4.sendEmptyMessage(int what):发送空消息
5.final Boolean send EmptyMessageDelayed(int what ,long delayMillis):指定时间(毫秒)发送空消息
6.final boolean sendMessage(Message msg):允许安排一个带数据的Message对象到队列中,等待更新
一，使用Handler在子线程中向UI线程发送一个消息进行UI更新
二，创建一个Message,Message msg=new Message()；msg.arg1=12;msg.obj=***;可以传递对象
7.final boolean sendMessageDelayed(Message msg,long delayMillis):指定多少时间(毫秒)之后发送消息

2.传递Runnable对象。用于通过Handler绑定的消息队列,

post(Runnable)
post(Runnable,long)
postDelaved(Runnable long)
post类允许你排列一个Runnable对象到主线程中,比如 使用PostDelayed方法，两秒后调用此Runnable对象 ,handler.postDelayed(runnable, 2000); ,实际上也就实现了一个2s的一个定时器

3.传递Callback对象,CallBack用于截获handler发送的消息,返回true就截获成功

public Handler tHandler=new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message message) {
        return false;
    }


});

Handler 原理

Handler封装了消息发送
Looper：内部包含一个消息队列也就是MessageQueue ，所以的Handler此队列发送的消息都走向这个队列
Looper.loop(),该方法是个for死循环，不断的从MessageQueue取消息,有消息就处理消息,没有就阻塞
MessageQueue，消息队列,可以添加消息，处理消息
Handler
在构造Handler的时候内部会跟Looper进行关联,通过Looper.myLooper()获取到Looper,找到Looper,也就找到了MessageQueue。在Handler中发送消息,其实是向MessageQueue中发送消息.

Handler，Looper和MessageQueue的关系

Looper和MessageQueue一一对应，创建一个Looper的同时，会创建一个MessageQueue。而Handler与它们的关系，只是简单的聚集关系，即Handler里会引用当前线程里的特定Looper和MessageQueue。这样说来，多个Handler都可以共享同一Looper和MessageQueue了。当然，这些Handler也就运行在同一个线程里

关系图

Handler与子线程

Handler不仅可以更新UI，你完全可以在一个子线程中去创建一个Handler，然后使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建Handler实例的线程中运行

class  TestThread extends Thread{
        public Handler handler;
        @Override
        public void run() {
            super.run();
            Looper.prepare();
            handler=new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    Log.i("tttt",Thread.currentThread().getName());
                }
            };
            Looper.loop();
        }
    }

一般UI主线程不做耗时操作,我们通过子线程消息来处理耗时操作

来看下HandlerThread

HandlerThread本质上就是一个普通Thread,只不过内部建立了Looper.其实使用HandlerThread的效果和使用Thread+Handler差不多

   private HandlerThread mHandlerThread;
    //子线程中的handler
    private Handler mThreadHandler;
 private void initThread()
    {
        mHandlerThread = new HandlerThread("check-message-coming");
        mHandlerThread.start();

        mThreadHandler = new Handler(mHandlerThread.getLooper())
        {
            @Override
            public void handleMessage(Message msg)
            {
                update();//模拟数据更新

                if (isUpdateInfo)
                    mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
            }
        };

    }
      private void update()
    {
        try
        {
            //模拟耗时
            Thread.sleep(2000);
            mMainHandler.post(new Runnable()
            {
                @Override
                public void run()
                {
                    String result = "每隔2秒更新一下数据：";
                    result += Math.random();
                    tvMain.setText(result);
                }
            });

        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }

    }

主线程和子线之间的信息交互

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ThreadTest threadTest=new ThreadTest();
        new Thread(threadTest).start();//开启子线程
    }


    private Handler handler=new Handler(){
        // 接收消息
        public void handleMessage(Message msg){
            switch (msg.arg1) {
                case 1:
                  Log.i("tttt","");
                    break;
                default:
                    break;
            }
        }
    };

    // 创建子线程，在子线程中处理耗时工作
    private class ThreadTest implements Runnable{
        public void run() {
            // TODO Auto-generated method stub
            try{
                Thread.sleep(1000);
            }
            catch (Exception e) {
                e.printStackTrace();
            }
            Message msgMessage=new Message();
            msgMessage.arg1=1;
            handler.sendMessage(msgMessage);
        }

    }


}

全文完!