Android消息机制（Handler、MessageQueue和Looper三者的工作原理）

Android的消息机制中有三个重要的类：Handler、MessageQueue和Looper。其中MessageQueue是先进先出的消息队列，它存储一组消息，有插入和删除的功能；Looper是循环的意思，主要功能是轮询MessageQueue里面的消息，然后交由Handler处理，如果暂时没有消息，则会等待；Handler主要统筹Looper和MessageQueue的功能，实现消息的发送和处理。

在Handler中，一个线程最多只有一个Looper，但线程默认是没有Looper的，需要自己创建，在Android的UI线程中可以直接使用Handler是因为在创建主线程的时候已经初始化了Looper；在Handler机制中有一个叫ThreadLocal的类，ThreadLocal不是一个线程，它的作用是可以为每个不同的线程存储数据，并且这些不同线程的数据互不干扰，而Looper就是通过它来保存在线程中的，通过调用ThreadLocal的get方法，可以获取当前线程的Looper对象。

ThreadLocl的工作原理

先来看一个例子：

    private java.lang.ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public void test() {
        
        threadLocal.set("主线程");

        LogUtils.d(Thread.currentThread().getName() + "的值=" + threadLocal.get());

        new Thread("线程01") {
            @Override
            public void run() {
                super.run();
                threadLocal.set("线程01");
                Log.d("tag", Thread.currentThread().getName() + "的值=" + threadLocal.get());
            }
        }.start();

        new Thread("线程02") {
            @Override
            public void run() {
                super.run();
                //threadLocal.set("线程02");
                Log.d("tag", Thread.currentThread().getName() + "的值=" + threadLocal.get());
            }
        }.start();

    }

执行test方法结果如下：

从执行结果来看，threadlocal确实可以为不同的线程保存各自的数据，来看看源码是怎么实现的：

    public void set(T value) {
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取当前线程的threadlocalmap
        ThreadLocalMap map = getMap(t);
        //如果threadlocalmap不为null，那么将value值保存，其中key值为当前threadlocal
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

   //返回线程的threadlocalmap对象 
   ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

  //创建对应线程的threadlocalmap实例，并且保存对应的值
  void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

其实这里的关键是将value值保存到当前线程的threadlocalmap中去，而且对应的key是threadlocal本身，来看看threadlocal的get方法：

   public T get() {
        //获取对应的线程
        Thread t = Thread.currentThread();
        //获取对应线程的threadlocalmap
        ThreadLocalMap map = getMap(t);
        //如果不为null，将取出key为当前threadlocal对应的value
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //threadlocalmap为null的时候，返回setInitialValue的值，其实就是null
        return setInitialValue();
    }

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

    protected T initialValue() {
        return null;
    }

代码都不复杂，当我们调用threadlocal的set方法保存某个value的时候，其实在set方法内部会获取当前线程的threadlocalmap，然后将value保存到threadlocalmap中，当我们调用threadlocal的get方法的时候，同样也是首先获取到当前线程的threadlocalmap，将保存在其中的value取出来

大概就是每个Thread都有自己的ThreadLocalMap，在ThreadLocal保存数据的时候，会根据当前线程对象拿到对应的ThreadLocalMap并将数据保存到里面，然后取数据的时候，也是先拿到对应Thread的ThreadLocalMap对象， 再取其中的数据，说白了线程能独立保存数据而不受其他线程的干扰，就是因为保存数据的时候首先获取当前线程对象，然后将数据保存到对应线程的ThreadLocalMap中

MessageQueue的工作原理

messagequeue的插入和读取操作内部是由先进先出的单链表结构来实现的，可能是因为单链表结构在插入和删除上效率比较高吧，插入用enqueueMessage方法，读取用next方法来实现，下面我们来看看他们的源码：

 boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use."