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

全文完!