Android消息通信机制Handler详解，Handler，Looper，MessageQueue,源码解析，讲解这几个类怎么配合工作的

                                                             android的消息机制Handler

 

 

 

说到Handler大家都不陌生，我们在平常会经常使用，Handler就是子线程和UI线程(ActivityThread)进行通信，还有就是当我们做I/O操作时（数据库操作，访问网络）这些耗时操作android规定不能再主线程执行（开辟子线程在子线程执行），否则主线程5S内无响应会导致ANR的出现，当我们在子线程

访问网络获取到数据后，想展示在控件上这时Handler的价值就体现出来了。

 

 

 

那么为什么android规定不能再子线程更新UI呢？因为android的Ui控件不是线程安全的，当多个线程并发的访问UI控件的话，会发生一些意想不到的后果，

如果Ui控件加上线程安全会使Ui控件这一块的逻辑异常复杂，降低UI的访问效率

 

android中使用Handler得有MessageQueue，Looper的支撑，

MessageQueue就是消息队列，内部的存储结构是单链表的形势，用于存储Handler发送过来的消息对外提供删除和插入数据的工作，MessageQueue只是用于存储数据， 而不能够处理数据，这时Looper的价值就体现出来了，其实Looper的工作就是通过调用Looper.loop（）会是进入一个无限循环的状态每到MessageQueue有数据就将其取出，没有就处于等待状态，在Looper中实例化一个成员，那就是ThreadLocal，它并不是线程，它的作用是存储每个线程中的数据，Handler获取当前线程的Looper就是通过ThreadLocal来获取的，下面将通过一个一个类来给大家进行介绍，然后再在把Handler执行过程中的类串联起来，讲解一下Handler的执行过程，以及涉及到的类是怎么配合工作的。

 

ThreadLocal：（线程局部变量）

ThreadLocal<>，其实它是一个泛型类，而不是一个线程，那么此类的作用，官方也给详细的解释，TreadLocal类，是存储数据用的，它存储的数据是有局限性的，它仅限于存储线程内部的数据（比如:线程创建Looper），它能指定线程存储数据，也能指定线程取出数据，各线程之间互不干扰，它提供了2个方法，一个set（），一个get（）当我们调用set（）方法时，它会获取你当前的线程，刚才已经说到ThreadLocal<>它仅限于存储线程内部的数据，其实在获取到的当前线程内部有一个成员变量是，ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocalMap是ThreadLocal的一个内部类，就是封装我们存入的数据，大家可以看到它的默认值是null，就是当我们set（）时，

set（）的源码如下：

public void set(T value) {
    //当使用set方法时它会得到set()时的当前线程， //每个当前线程的内部都有一个ThreadLocal.ThreadLocalMap threadLocals = null，用于保存当前线程的ThreadLocalMap值
    Thread t = Thread.currentThread();
      //返回当前线程的ThreadLocalMap数据
    ThreadLocalMap map = getMap(t);
    //如果查询出当前线程的存在，会把要保存的数据保存当前线程的ThreadLocalMap中，比如：Looper，因为下次取数据的时候，要根据线程ThreadLocalMap取出Looper
       if (map != null)
        //存入数据及当前ThreadLocal的索引
        map.set(this, value);
    else
        //如果当前线程ThreadLocalMap不存在，就会给当前线程初始ThreadLocalMap    createMap(t, value);
}

getMap（t）方法的执行

ThreadLocalMap getMap(Thread t) {
    //返回当前线程的ThreadLocalMap数据
    return t.threadLocals;
}

createMap(t, value);方法的执行

//如果当前线程ThreadLocalMap不存在，就会给当前线程初始化ThreadLocalMap
void createMap(Thread t, T firstValue) {
    //参数1，代表当前的ThreadLocal，参数2代表要存入的数据
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

以上代码执行做到了它能指定线程存储数据，下面在介绍一下get（）

通过代码可以看到get（）也可以指定线程取出数据

public T get() {
    Thread t = Thread.currentThread();
    //从当前线程中ThreadLocalMap数据
    ThreadLocalMap map = getMap(t);
    //判断当前线程中ThreadLocalMap数据
    if (map != null) {
        //根据当前ThreadLocal的索引值查询对应的value值
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T) e.value;
            return result;
        }
    }

    //返回初始值null
    return setInitialValue();
}

ThreadLocal基本上已经介绍完毕，那么接下来就到了我们的重头戏了。

Looper：

就是Looper其实说到Looper大家多多少少不会陌生，在大家的印象中它应该是消息轮询器，对没错，其实它是整个消息的构建与处理系统，线程是没有Looper的，我们需要自己去构建，当然UI线程除外，UI线程在程序启动的时候，系统就为我们构建了Looper，每个线程必须保证Looper的唯一性，重复创建会抛出异常，

throw new RuntimeException("Only one Looper may be created per thread");

首先带大家看Looper类里的一个成员变量，

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

上面已经说过这个类的作用，就是为当前线程保存数据，

创建Looper也非常简单我们只需要调用Looper.prepare()即可下面咱们看一下调用prepare（）之后做了什么。

public static void prepare() {    

prepare(true);
}

大家可以看到prepare()内部有调用了一个prepare（true）咱们继续跟进

private static void prepare(boolean quitAllowed) {
    //当sThreadLocal.get() != null说明Looper已经存入！抛出异常，保证Looper唯一性
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");   }
    //创建Looper存储到ThreadLocal
    sThreadLocal.set(new Looper(quitAllowed));
}

大家可以看到这时ThreadLocal派上了用场，它去判断了当前线程是否已经有Looper，有的话就抛出异常，保证线程只能有一个Looper，在往下看//创建Looper存储到ThreadLocal
    sThreadLocal.set(new Looper(quitAllowed));

可以看到当Looper不存在的时候，创建Looper，可以看到使用的是sThreadLocal.set()这就是Looper和当前线程关联上了，在看Looper的构造器做了什么

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

可以看到创建消息队列。

接下来还有种创建Looper的方法就是UI线程创建时调用的方法

//主线程调用此方法创建Looper
public static void prepareMainLooper() {

//可以看到也是调用prepare()方法
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        //myLooper方法会返回当前线程的Looper对象
        sMainLooper = myLooper();
    }

这个方法没什么说的，也是执行了之前创建Looper的方式。

//接下来又到了Looper内一个很重要的方法，那就是，Looper.loop()

loop()方法，的作用就是会采用无限循环的方式去消息队列中取数据，如果消息队列没有数据可取，它就陷于等待状态，当然当我们创建Looper，而不去调用loop()，它不会报错，而是发送的消息不会取出来，当然你如果当前线程没有Looper，调用loop()它也会抛异常：

loop()源码如下：

public static void loop() {
    //获取当前线程的Looper
    final Looper me = myLooper();
    //判断当前线程是否存在Looper，如果Looper不存在，在调用loop（）方法时就给它抛出异常
    if (me == null) {
        // 当Looper没有创建时调用loop()轮询数据抛出异常，o Looper; Looper.prepare() wasn't called on this thread.
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    //获取当前线程Looper的消息队列
    final MessageQueue queue = me.mQueue;

    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    //进入无限循环，轮询数据
    for (; ; ) {

        //从消息队列中取出每一个消息（Message）
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }

        // This must be in a local variable, in case a UI event sets the logger
        //这一定是在一个局部变量,以防UI事件设置记录器
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        final long end;
        try {
            //调用消息关联的Handler通过dispatchMessage分发给handleMessage(Message msg)处理消息
            //msg.target其实就是Handler对象
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        if (slowDispatchThresholdMs > 0) {
            final long time = end - start;
            if (time > slowDispatchThresholdMs) {
                Slog.w(TAG, "Dispatch took " + time + "ms on "
                        + Thread.currentThread().getName() + ", h=" +
                        msg.target + " cb=" + msg.callback + " msg=" + msg.what);
            }
        }

        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

        // Make sure that during the course of dispatching the
        // identity of the thread wasn't corrupted.
        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的工作原理核心部分已经介绍完毕，接下来讲解MessageQueue

MessageQueue：

              MessageQueue消息队列，说到消息队列，其实就是用于存储我们发送的Message，在存储时其实它是有时间顺序的，包括取出时都有时间顺序，因为我们在发送的时候可能会延迟发送一些消息，其实在内部存储的时候，它用到的是单链表的的方式进行存取，因为在消息队列中，我们做的最多的操作，无非就是存，取，这样单链表的存取效率更高些，说了那么多，核心的方法就2个，取数据next()，存数据enqueueMessage()。

先说一下enqueueMessage()，是被Handler调用的，当Handler发送消息的时候，会把消息加入到消息队列，源码如下：

//enqueueMessage是被Handler调用的，当Handler发送消息的时候，会把消息加入消息队列，消息队列的消息是按待处理时间排序的
boolean enqueueMessage(Message msg, long when) {
    //判断当前发送的消息是否和Handler绑定
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    //这个属于Message的消息池，判断消息是否在使用
    if (msg.isInUse()) {
        throw new IllegalStateException(msg + " This message is already in use.");
    }

    synchronized (this) {
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

        msg.markInUse();
        //将你指定的延迟时间赋值给了Message的when内部进行了按时间的顺序进行存入
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        //以下代码是单链表的方式插入数据
        if (p == null || when == 0 || when < p.when) {
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            // Inserted within the middle of the queue.  Usually we don't have to wake
            // up the event queue unless there is a barrier at the head of the queue
            // and the message is the earliest asynchronous message in the queue.
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (; ; ) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

//接下来再看next()这个方法就是返回消息队列中的Message，此方法被loop()内部调用，源码如下：

//最重要的方法是next，被Looper的loop（）方法调用，用于获取下一个Message对象，如果没有需要处理的Message对象，该方法将阻塞，
//其实呢，next方法整体就是一个无限循环的状态，从消息队列中取数据，有数据就取，取完后从单链表中移除，没有就堵塞
Message next() {
    // Return here if the message loop has already quit and been disposed.
    // This can happen if the application tries to restart a looper after quit
    // which is not supported.
    //这个值调用的so文件，
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    //每个Message对象都有一个什么时刻处理该Message对象的属性when，没到时间都不会处理该Message对象
    for (; ; ) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;

         //从单链表取出一个Message
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                //根据时间去按照顺序返回Message
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    // 获得了一个Message对象，
                    mBlocked = false;
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    //将其返回
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.          //以下代码取出数据以后，变更单链表的长度
            if (mQuitting) {
                dispose();
                return null;
            }

            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }

            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler

            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }

        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;

        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

Hnadler:

Handler用于发送消息和最终通过handlermessage()方法把结果给我们让我们用于处理自己的逻辑，Handler在哪个线程创建时，会采用哪个线程的Looper，当我在其他线程通过Handler的引用方式消息时，通过Looper就能够实现线程的切换让我看一看创建Handler时都做了什么，

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

创建Handler时它执行了另一个构造方法

public Handler(Callback callback, boolean async) {
//…………   

    //获取当前线程Looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
    }
    //通过当前线程Looper获取MessageQueue
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
    //通过 mLooper = Looper.myLooper();和mQueue = mLooper.mQueue;
    //就可以看出Handler和当前的Looper中实例的MessageQueue已经关联起来了
}

//可以看到创建Handler时获取到了当前线程的Looper，在看一下发送消息的方法，无论是post方式发送，send一系列的方法发送，最终都会走

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    //其实在刚才创建时已经获取到了Looper中MessageQueue的赋值给了mQueue
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    //将消息存入消息队列
    return enqueueMessage(queue, msg, uptimeMillis);
}

可以看到传入了一个我们要发送的消息，和一个时间，它又调用了

//将消息存入消息队列
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    //得到handler发送消息时的Message通过target字段和当前Handler绑定
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    //最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，
    // 最终会保存到消息队列中去。
    return queue.enqueueMessage(msg, uptimeMillis);
}

具体的使用会在代码演示，具体说到android规定不能够在UI线程更新UI，实际上ViewRootImpl的

void checkThread() {

        if (mThread != Thread.currentThread()) {

            thrownew CalledFromWrongThreadException(

                    "Only the original thread that created a view hierarchy can touch its views.");

        }

} 

对当前线程进行了检测 ，ViewRootImpl它是View树的树根

,UI线程的Looper在ActivityThread

         Looper.prepareMainLooper();

           //创建ActivityThread 对象

           ActivityThread thread = new ActivityThread();

           thread.attach(false);

           

           if (sMainThreadHandler == null) {

                    sMainThreadHandler=thread.getHandler();

           }

 

           if (false) {

               Looper.myLooper().setMessageLogging(new

                        LogPrinter(Log.DEBUG, "ActivityThread"));

           }

   

           Looper.loop();

   

           thrownew RuntimeException("Main thread loop unexpectedlyexited");

       }

作者：MeloDev
链接：https://www.jianshu.com/p/0efc71f349c8
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

总结：

使用Handler机制发送消息首先当前线程必须先有Looper，而且也要保证Looper的唯一性，在使用Handler的时候它会采用当前线程下的Looper，就是先创建Looper，然后Looper的构造器会创建对应的MessageQueue，在创建Handler的时候，内部会获取当前线程下的Looper，以及MessageQueue，当我们send…的时候，会通过Message的target字段和Handler了绑定，然后在调用enqueueMessage(msg, uptimeMillis)将消息存入进MessageQueue

之后在通过Looper的loop()进入无限循环调用MessageQueue的next（）方法取出数据，在loop()方法内通过Message绑定的target字段进行分发给对应的handlermessage进行处理。

面试题：

创建Message时obtain和new 的方式有什么区别？

采用obtain方式创建Message实际上Message内部有一个消息池，它会从消息池中取出Message如果没有新建一个，减少内存的开销

new 的方式是直接新建一个Message。

使用Handler会出现内存溢出的情况：

在java中非静态内部类和匿名内部类都会隐式持有当前类的外部引用，由于Handler是非静态内部类所以其持有当前Activity的隐式引用，如果Handler没有被释放，其所持有的外部引用也就是Activity也不可能被释放，当一个对象一句不需要再使用了，本来该被回收时，而有另外一个正在使用的对象持有它的引用从而导致它不能被回收，这导致本该被回收的对象不能被回收而停留在堆内存中，这就产生了内存泄漏，

解决方法主要在于两点：
1.将Handler声明为静态内部类。因为静态内部类不会持有外部类的引用，所以不会导致外部类实例出现内存泄露。
2.在Handler中添加对外部Activity的弱引用。由于Handler被声明为静态内部类，不再持有外部类对象的引用，导致无法在handleMessage()中操作Activity中的对象，所以需要在Handler中增加一个对Activity的弱引用。