Android Handler消息机制原理及总结

Android中的消息机制主要就是指Handler的消息机制，Handler相信大家已经非常熟悉了，它可以将一个任务切换到Handler所在的线程中去执行，开发中，当我们在子线程做了一些操作后需要更新UI，由于Android不允许在子线程中访问UI控件，所以我们一般都会使用handler来实现。

Handler的机制需要MessageQueue、Looper和Message的支持。他们在消息机制中各扮演了不同的角色

Handler：负责消息的发送和接收处理
MessageQueue：消息队列，一个消息存储单位，经常需要进行增减，内部使用的是单链表的结构
Looper：消息循环。会不停地从MessageQueue中取消息，如果有新消息就会立刻处理，否则就一直阻塞在那里
Message：消息载体

下面通过一段简单的代码来分析整个执行过程。

 private TextView textView;
 private Handler handler = new Handler(){
     @Override
     public void handleMessage(Message msg) {
          super.handleMessage(msg);
          textView.setText("消息处理.....");
     }
 };
@Override
protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.mytv);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //模拟耗时操作
                SystemClock.sleep(3000);
                handler.sendMessage(new Message());
            }
        }).start();

    }

就是在子线程中做了一些耗时操作后，通过Handler发送消息去更新UI

Hanlder是怎么接受到消息的呢？

Looper

Looper几个主要的方法

• Looper.prepare()：为当前线程创建一个Looper
• Looper.loop()：开启消息循环
• Looper.getMainLoop()：可以在任何地方获取到主线程的
• Looper.quit()：直接退出Looper
• quitSafely()：设置一个标记，把消息队列的所有消息处理完后才会退出

//创建一个新的Looper并放到当前线程的ThreadLocal中去
 private static void prepare(boolean quitAllowed){
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

再看看Looper的构造方法，发现，Looper中保存有一个MessageQueue

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

loop()该方法是一个死循环，会不断从MessageQueue中去取消息，当获取到消息后，将交由Handler去处理

public static void loop() {
    //myLooper方法会从ThreadLocal中获取到当前线程的Looper
    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;
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    for (;;) {
        //不断的去MessageQueue中取消息
        Message msg = queue.next();
        if (msg == null) {
            return;
        }    
       Printer logging = me.mLogging; 
       if (logging != null) {
          logging.println(">>>>> Dispatching to " + msg.target + " " +                msg.callback + ": " + msg.what);    } 
      //调用发送该消息的Handler的dispatchMessage方法处理该消息
      //这里的msg.target == Handler，是在Handler发送消息的时候进行赋值的
       msg.target.dispatchMessage(msg); 
       if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);    } 
       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();
}

Looper大概就是这么一回事，每条线程绑定一个Looper（子线程需要自己调用Loop.prepare())，保证每条线程都只有一个Looper实例
随后调用Looper.loop开启消息循环，进入堵塞状态，等待消息的到来

MessageQueue

相对来说就很简单来，就两个操作，插入和读取。可以看成一个消息容器

Handler

先来看看他的构造方法

```java
public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        final Class klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) { 
           Log.w(TAG, "The following Handler class should be static or leaks might occur: " +                klass.getCanonicalName());        }   
 } 
  //获取当前线程中的Looper
   mLooper = Looper.myLooper();
    if (mLooper == null) { 
    //如果当前线程没有Looper就会抛出异常。
       throw new RuntimeException(            "Can't create handler inside thread that has not called Looper.prepare()"); 
   } 
   //获取Looper中的MessageQueue，可以看出,Looper中为每个线程维护了一个Message
   mQueue = mLooper.mQueue; 
   mCallback = callback;
   mAsynchronous = async;
}

接来下看看Handler发送消息的方法，追踪senndmessage到最底层的方法就是enqueueMessage。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

主要做了两个操作
msg.target = this;将发送的Message的target指向当前Handler。
ueue.enqueueMessage(msg, uptimeMillis);往当前线程的MessageQueue插入一条消息

前面在Looper.looper()方法中我们看到msg.target.dispatchMessage(msg); 获取到消息后，调用Handler的dispatchMessage方法进行消息处理。

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);//这里是Message的Callback，也就是开启我们在postDelayed传入的Runnable
    } else {
      //mCallback：构造器传入的实现
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                   return;
            }
        }
      //handler自己的handler，一般由派生之类来实现
        handleMessage(msg);
    }
}

可以看到Handler最终将调用handlerMessage处理消息，当然这里的handlerMessage处理是有优先级的

下面我们总结下流程
流程总结：
1，首先调用Looper.prepare()方法，会创建一个Looper实例，该实例包含一个MessageQueue，并将该实例保存在当前线程中Threadlocal
2，调用Looper.loop()开始消息循环，不断地向MessageQueue中读取消息，并调用msg.target.dispatchMessage(msg);来处理消息
3，构建Handler的时候，会先获取到当前Handler所在线程的Looper并得到其中的 MessageQueue
4，使用Handler发送消息的时候，会将一个Message到保存当前线程Looper中的MessageQueue
5，当Looper.loop()获取到消息的时候，调用msg.target.dispatchMessage(msg)来处理消息,其实Message.target = handler。也就是调用Handler的dispatchMessage来处理
6，Handler的dispatchMessage最终回去调用handlerMessage方法。到这里就知道，其实Handler的handler在哪条线程执行，取决于构建Handler时所使用的是哪条线程保存的Looper，因为handlerMessage其实是Looper去调用的。

下面通过一张图来表述下具体流程

这里写图片描述

前面说到，Handler必须有Looper才能执行，或者会就抛出异常，当前我们在日常使用中，直接在Activity中定义Handler就可以用啦，并没有说调用Looper.prepare来进行初始化操作。

其实UI线程默认已经做了这些操作了。对于我们来说是隐形的

大家都知道Android的程序入口是ActivityThread类，他有个main方法，我们看看他做了什么

 public static void main(String[] args) {
        //省略。。。。

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        AsyncTask.init();

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

可以看到main方法主要就是消息循环，当main方法结束了，你的程序也就退出了

可能有人会问？UI线程已经做了Looper.loop()了？loop不是一个死循环堵塞状态吗？为什么我们程序还能跑起来。

既然main方法只是做了消息循环，那么我们Activity的生命周期的方法是怎么执行的呢？
在ActivityThread中有个Handler，Activity的生命周期方法在里面均有case，也就说是我们的代码其实就是在这个循环里面去执行的，自然不会阻塞了

当前我还有个疑惑。程序是在哪给ActivityThread的Handler发消息的呢？这个我暂时还不清楚。。还得继续学习啊。

UI线程已经帮我们做了这些工作了，但是如果我们自己new Thread的话，需要在子线程中使用Handler的话，还是要自己来实现的。
对此，Android也为我们提供了一个HandlerThread类，方便我们快速的实现需求。
HandlerThread继承了Thread

public class HandlerThread extends Thread

代码相当简单，
看看run方法

 @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

如果对前面的Handler机制理解了话，这里是不是一目了然了呢？