Android消息机制再探究

Android消息机制的在探究

之前写过一篇关于Android的内部消息机制的文章，现在回头在看看发现还是有很多不足之处的，加之在使用过程中对这方面的内容又有了进一步的了解，所以在这里对消息机制在做一次深入的分析。
在分析之前，我们需要弄清楚几个问题：
1. 消息机制在能够干什么
2. 消息机制在Android中的地位
3. 探究其实现原理

一，Android消息机制的作用
大家也都经常使用Handler做UI更新操作，所以大部分都是认为Handler就是用来做UI更新用的，因为子线程是不能更新UI的，需要使用Handler机制也做UI的更新操作，这是大家的共识。没错，Handler的确是ui更新比较好的方式。 其实，我个人觉得android这套消息机制，是线程之间的通信机制，只是用的比较多的是ui更新操作而已。在理说的ui线程，也就是主线程，这个线程是用来循环接受子线程的消息，并交给发送该消息的handler去处理。 也就是说只有”主线程”才能接受handler发送的消息，其实确切的说应该是Looper线程才能接受handler发送的消息，显然ui线程也是Looper线程，至于为什么是Looper线程，这个稍后分析，而Looper线程不仅仅是UI线程，任何一个子线程都可以成为Looper线程。 好了，现在我们已经知道Android这套消息机制可以用来说多线程之间的通信，和数据传递的功能，而且很强大。

二，Android消息机制的地位
地位要从功能说起，上面已经看到消息机制很强大，也很好用。可以说消息机制在Android中的地位是举足轻重的，而且设计思想也很优秀，值得深究。framework源码中用到Handler的地方非常多，比如异步数据库查询类AsyncQueryHandler，AsyncTask等这些都是对handler机制的封装。以及源码中两个Handler之间的通信使用是特别频繁，如果不理解这些内部原理，看上去是眼花缭乱。 对于这么重要的消息机制，要想好好的使用必然是要探究一下其原理的。

三，消息机制原理分析
Handler这一套机制主要设计的类如下：
Handler
Looper
Message
MessageQueue
ThreadLocal
对于上面设计到的核心类进行一一的分析

1. ThreadLocal

   这是一个线程内部的存储类，可以在执行的线程中存储数据，所以也只能在指定的线程中获取数据。这样说起来比较抽象，比如对于一个boolean类型的变量，多个线程都需要存储和获取这个数据，并且要求这些个线程之间对与该变量的存储和获取是互不干扰的，即在每个线程中都存在这个变量的存储副本(注意这个时候线程之间对这个变量的访问不是互斥的，因为每个线程都是有副本的，所以不需要互斥访问)。在这样的情况下，我们可以使用TheadLocal也实现。这里Looper使用了这个机制，那么Looper为什么需要使用这个机制呢？ 也就是说，每个线程中都有一个独立的Looper副本，而每个Looper中都关联一个消息队列，再结合之前说的每个线程都可以成为Looper线程，我们可以就可以理解这么做的原因，那是因为这样可以使线程内的消息队列在线程之间是相互独立的，每个Looper线程值处理其对应的handler发送的消息，这样就很容易的做到消息机制的有条不紊的进行。而且多个线程之间也不会出现消息处理错乱问题。 对与理解ThreadLocal的运行原理，可以执行这样一个例子：

private ThreadLocal<Boolean> mBoolean = new ThreadLocal();
mBoolean.set(true);
System.out.println(Thread.currentThread() + " " + mBoolean.get());

new Thread(new Runnable {
    public void run() {
        mBoolean.set(false);
        System.out.println(Thread.currentThread() + " " + mBoolean.get());
    }
}, "thread1").start()

new Thread(new Runnable {
    public void run() {
        System.out.println(Thread.currentThread() + " " + mBoolean.get();
    }
}, "thread2").start()

上面的例子中执行结果是main true, thread1 false, thread2 null
上面的log出现不分先后顺序，这里例子可以看出mBoolean在三个线程中都有备份，互不影响。 ThreadLocal就说到这。

2.消息Message和MessageQueue
对于Message就是我们需要发送的消息的载体，即是当我们使用sendMessage发送的具体内容的携带者，arg1, arg2, what,obj等变量来携带需要传递到Looper线程的内容。
对于MeaageQueue从字面意思就可以理解这是一个消息队列，用来存储消息和获取消息的地方。虽然是叫做消息队列，其内部并维护的并不是队列，实际上是通过一个单链表也维护消息列表的。 MessageQueue中有两个主要的方法enqueueMessage()和next(). enqueueMessage()源码如下

boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
        /*这里msg必须有target，止于handler和msg是何时关联   的，后面分许*/
    }
    ...
    synchronized(this) {
        /**
            这里就是单链表的插入操作，不做具体分析
        */
    }
}

下面看next()方法的源码

Message next() {
    /** 取出消息，并出链表中移除*/
    ...
    for (;;) {
        /** 这里的for循环是在等待消息，没有消息就阻塞。消息一旦出现，next就会返回这条消息，并从链表中将其移除*/
    }
}

对于Message和MessageQueue, 前者是线程间传递内容的载体，后者是前者队列的维护。

1. Looper循环者
   Looper是循环着，即是不停的查看MessageQueue中是否有新的消息，如果有就立即处理，否则一直阻塞。首先看其构造方法

private Looper (boolean queitAllowed) {
    //Looper内部有一个消息队列的引用
    mQueue = new MessageQueue(quitAllowed);
    //关联当前的thread，即looper所在的thread
    mThread = Thread.currentThread();
}

我们知道Handler的工作必须要有Looper参与，想要让一个线程成为looper线程，其实也很简单

public class LooperThread extends Thread() {
    public void run() {
    //将当前线程初始化为looper线程
        Looper.prepare();
        ...
        //开始循环处理消息队列
        Looper.loop();
    }
}

通过上面的两行核心代码，我们就可以将一个普通线程变为looper线程，下面也具体分析实现过程

首先看prepare()方法的实现

public static void  prepare() {
    prepare(true);
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() == null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    //存储当前线程的looper对象，且值创建一个
    sThreadLocal.set(new Looper(quitAllowed));
}

当Looper.loop()调用之后，Looper才真正的开始工作，不断的从消息队列中取出消息并执行

public static void loop() {
    final me = myLooper(); //获取当前线程的Looper对象
    if (me == null) {

    }
    //当前looper的MessageQueue
    final MessageQueue queue = me.mQueue;
    ...
    //这里开始进入循环，取消息，处理
    for (;;) {
        Message msg = queue.next();

        /**交给Message关联的handler去处理，这里将消息处理的过程有切换到Looper线程*/
        msg.target.dispathMessage(msg);
        ...
    }   
}

实现Looper线程的过程分析完了，从这里我们起码可以看出三个结论
1. 每个线程只能有一个Looper对象，因为这是一个ThreadLocal的变量
2. 调用Looper.prepare()方法可以使一个线程变为looper线程
3. Looper中有一个MessageQueue的实例，loop()方法，进行循环取消息。
分析到这里，MessageQueue，Looper, 当前的线程都关联起来了，下面就是消息的发送和处理，以及Handler和Msg的关联，Handler的消息队列和Looper内部的消息队列相互对应起来

4.异步处理Handler
Handler的主要工作是在子线程中发送消息和在Looper线程中接受消息并处理之。首先看Handler的构造方法

public Handler(boolean async) {
    this(null, async);
}

public Handler(CallBack callback, boolean async) {
    ...
    //Handler持有Looper的引用
    mLooper = Looper.myLooper();
    /**Handler的queue和Looper.mQueue关联，这样就是Handler消息入队和Looper出队的是同一个队列*/
    mQueue = mLooper.mQueue;
    ...
}

/** 这个构造方法可以用来为Handler指定Looper线程*/
public Handler(Looper looper, Callback, boolean) {
    mLooper = looper;
    mQueue = looper.mQueue;
    ...
}

从上面的构造函数可以看出，Handler持有Looper的引用，也持有MessageQueue的引用，而且Handler和Looper持有的m
Queue是同一个消息队列的引用，这样才能实现消息的发送和接受处理。接下来看Handler发送消息的过程

public final boolean sendMessage(Message msg) {
    return sendMessageDelayed(msg. 0);
}

public final boolean sendMessageDelayed(Message, long) {
    ...
    return sendMessageAtTime(...);
}

 public boolean sendMessageAtTime(Message msg, long uptimeMillis)  {
    ...
    return enqueueMessage(...);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    /**这里指定msg的执行这为当前的handler对象，handler和msg就此也关联起来了*/
    msg.target = this;
    ...
}

上面就是Handler发送消息的过程，在发送消息的同时执行该消息的处理着，也就是发送该消息的Handler对象，该Handler对象位于Looper线程中。
注：一个Looper线程只能有一个Looper对象，这个是ThreadLocal决定的，而一个线程可以有多个Handler对象，当然这多个Handler对象是共同使用一个消息队列的，看源码可知。所以在使用时可以根据任务的不同分为多个Handler进行处理。
在Handler中还存在一个Callback接口，这个有什么作用呢？

/** 当你不想继承Handler创建一个类时，可以使用这个接口*/
public interface Callback {
    public booelan handleMessage(Message msg);
}

所以Handler中也有相应的构造方法

public Handler(Callback callback) {
    this(callback, false);
}

一上就是对于Handler机制的分析，这里没有说如何使用Handler进行UI更新和子线程之间进行数据通信，，仅仅是从源码实现的角度进行分析。 下面看两个特殊的Looper线程

5.HandlerThread
这是Android系统为我们实现的一个Looper线程，继承Thread

public class HandlerThread extends Thread {
    ...
    public void run() {
        ...
        //循环初始化
        Looper.prepare();
        ...
        //进入消息循环
        Looper.loop();
    }
}

HandlerThread的实现，和之前分析Looper时说过的让一个子线程成为一个looper线程的步骤是一样的。所以，我们在使用时不需要自己去创建一个Looper线程，系统已经为我们实现好了，只要继承HandlerThread即可。 而在使用时只是需要将Handler的Looper关联对该looper线程即可。

MyHandlerThread ht = new MyHandlerThread();
Looper looper = ht.getLooper();
Handler handler = new Handler(looper);

上面可以看出HandlerThread使用起来很方便，这里不在分析。

注：
在使用Handler的过程中，最容易出现的就是内存泄漏的问题。那么为什么会出现内存泄漏呢？
1) 在回头看一下Handler,Looper,Mesage它们的关系就会明了。Handler持有Looper和MessageQueue的引用，Message持有Handler的引用，MessageQueue也持有Message的引用，Looper持有MessageQueue的引用。如果某一个引用一直占用不能释放，就不能被回收，导致内存泄漏。
2) 继承Handler，并作为内部类时，Handler持有Activity的引用，如果子线程中的任务比较耗时，且在子线程完成之前，activity就退出，则Handler持有的activity，activity虽然已经销毁但内存还是得不到释放，可以使用静态内部类加弱引用的方法解决之(静态内部类是不持有外部类引用的)。比如：

static class MyHandler extender Handler {
    WeakReferene<Activity> mActivityRef;
    public MyHandler(Activity activity) {
        mActivityRef = new WeakReference<>(activity);
    }
    public void handleMessage(Message msg) {
        if (mActivityRef.get() != null) {
            //处理消息
        }
    }
}

3) 对于Message对象的获取

/** 可以通过这种方式获取*/
Message msg = new Message();

/** 推荐使用这样的方法来新建一个msg*/
Message msg2 = Message.obtain()

好了，关于Android的消息机制，其实我们打交道最多的就是上层的Handler接口，对于Looper，MessageQueue怎么实现的关心比较少，但是这样的线程间通信的思想是必须要理解滴。