Android-Handler机制

什么是HanlerThread类？

如果一个线程创建了Handler对象，同时也创建了Loop对象拥有MessageQueue，那么我们就可以说这个线程是HandlerThread.

Handler机制主要的几个类

• Handler:用来发送消息：sendMessage等多个方法，并实现handleMessage()方法处理回调

• Message:消息实体，发送的消息即为Message类型。

• MessageQueue:消息队列，是一个单链表,用于存储Message。发送消息时，消息入队列，然后Looper会从这个MessageQueue取出消息进行处理。

• Loop:与线程绑定，绑定的线程用来处理消息。loop()方法是一个死循环，一直从MessageQueen里取出消息进行处理。注意：Loop绑定的可以是子线程也可以是主线程

那么这里就有一个问题了：loop()方法是一个死循环，为什么不会被卡死呢？
答：简单的说，就是当MessageQueue中没有Message时，线程会挂起，一有消息，就会唤醒线程处理消息。
这几个类非常重要,也是我们这次要重点讲解的。

Handler

Handler可以发送什么
handler有两个工作，一是发送任务或者消息；二是处理消息或者执行任务。Handler和MessageQueue关系密切，Handler不单单能发送Message到MessageQueue,也可以发送Runnable.或者这么说MessageQueue不仅仅放Message也存放Runnable.

Handler的触发线程
通常Handler都是在创建线程创建，在非创建线程发送的(当然也可以在同一个线程中创建发送)，而handler处理消息或执行任务，则是在创建自己的线程（创建线程）中执行的。

创建Handler
handler和looper的创建并不是ui线程独有的。任何一个普通的线程，都可以创建自己的looper，创建自己的handler。但是有一点需要注意，创建handler前，必须先创建looper。
创建代码如下：

  /**
     * 在子线程创建Handler
     */
    public Handler mHandler;    
    class LooperThread extends Thread {        public void run() {            //调用Looper.prepare();语句来为当前线程new一个looper对象，将当前线程(子线程)与new出来的Looper关联
            Looper.prepare();
            mHandler = new Handler() {                public void handleMessage(Message msg) {

                }
            };            //Looper.loop()开启循环处理消息
            Looper.loop();
        }
    }

这里又有一个问题了？我们平时都是直接在Activit里new Handler(),为什么没有创建Looper对象呢？
答：主线程在启动的时候，默认就会调用Looper.prepareMainLooper() 创建looper，所以，我们可以在主线程直接创建handler，不需要手动先创建looper。

Handler发送Runnable
我们上面说了，Handler不单单可以发送Message还可以发送Runnabe，代码如下：

 /**
     * Handler发送Runnable
     */
    public void sendRunnable(){
        mHandler.postDelayed(new Runnable() {            @Override
            public void run() {
    
            }
        },3000);
    }

我们顺着看一眼源码：

 public final boolean post(Runnable r)
    {       return  sendMessageDelayed(getPostMessage(r), 0);
    } private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();//这里m.callback就是一个Runnable
        m.callback = r;        return m;
    }

用getPostMessage 把runnable包装成一个message，message的callback就是runnable。message.callback其实就是对runnable的封装,因此，分辨一个message是不是runnable，其实只要看message的callback是否为空，如果为空，就是普通的message，否则就是一个runnbale。

Handler处理消息
我们刚才说来了Handler可以发送Message，可以发送Runnabe，那么他是如何区分来处理消息的呢？我们来看一下源码Handler类中的dispatchMessage这个方法：

/**
     *在这里处理系统消息
     */
    public void dispatchMessage(Message msg) {        if (msg.callback != null) {
            handleCallback(msg);// handler.post(runnable)时走这里
        } else {            if (mCallback != null) { // handler = new Handler(callback)时走这里
                if (mCallback.handleMessage(msg)) {                    return;
                }
            }// handler = new Handler()时走这里
            handleMessage(msg);
        }
    }

根据handler发送消息的类型，分成2种情况：

handler发送了一个message到MessageQueue

handler发送了一个runnbale到MessageQueue

根据前面提到的，message.callback其实就是对runnable的封装，所以，如果handler是发送了一个runnable到MessageQueue，那么就会执行这个runnable。

如果handler是发送了一个message到MessageQueue，那么又细分为2种情况

• handler创建时设置了callback, 即handler = new Handler(callback);

• handler创建时未设置callback，即handler = new Handler();

如果设置了callback，那么message会先被callback处理。

如果callback返回true，说明处理完成，不会再传给handler.handleMessage了。

如果callback返回false，说明处理未完成，会再把message传给handler.handleMessage继续处理。

如果未设置callback，message会直接传给handler.handleMessage处理

Message

Message如何产生
Message一般是通过构造函数也就是new的方式产生，也可以通过Message.obtain()或Handler.obtainMessage()方式产生，建议使用Message.obtain()，因为此方法获取的Message对象是从可回收的消息对象池里面直接获取的，有利于性能提高。
当然handler.sendEmptyMessage()，可以发送一个空消息到MessageQueue，不需要构造一个message对象。

Message发送时机

• handler.sendMessage():
  Message发送时机的发送时机一般是由Handler决定的，比如我们常用的handler.sendMessage(Message message)方法，是把message放到MessageQueue的尾部排队，遵循先进先出的原则一个一个取消息发送。

• handler.sendMessageAtFrontOfQueue():
  把message放到message queue的头部，消息可以马上被处理。

• handler.sendMessageAtTime():
  不马上发送消息到message queue，而是在指定的时间点发送。

• handler.sendMessageDelayed():
  不马上发送消息到message queue，而是在指定的时延后再发送。

MessageQueue

MessageQueue 就是用来存储Message的，里面的Message默认先进先出。

Looper

Looper会从MessageQueue中取出Message，然后派发给handler处理。
Looper的创建
Loop.prepare();//此方法创建Looper对象，一个线程对应一个Looper对象
Looper的获取

  //获取主线程中的Looper
        Looper mLoop=Looper.getMainLooper();   //获取子线程或者Handler构造方法中的looper
                Looper mLooper=Looper.myLooper();

Looper派发消息
我们知道Looper通过 Looper.loop();来循环从MessageQueue发送新增Message.那么他是如何将Message和Handler对应呢,确保这个Message就是发送给这个Hander呢？
我们看一看loop方法：

image.png

每个msg都有一个target属性，这个target就是发送消息的handler，派发message，就是派发给msg.target对象。
loop方法并不是无限循环的，一旦message queue为空，就会结束，以免长期占用cpu资源。

总结：
handler不是独立存在的，一个handler，一定有一个专属的线程，一个消息队列，和一个looper并与之关联。
Handler机制实际是生产者和消费者模式，handler是生产者，生产消息然后添加到messagequeue；looper是消费者，从messagequeue里取message。
Handler,Looper,MessagQueue的工作流程是：

• handler发送消息到message queue，这个消息可能是message，也可能是runnable,还有可能使空消息

• looper负责从messagequeue取message

• looper把message通过dispatchMessage方法发送给给handler

• handler处理消息(handleMessage或者执行runnable)
  他们的关系可以用一张图说明：

  
  

  

  image.png

作者：薛之涛
链接：https://www.jianshu.com/p/3ba41f173844