书海拾贝|开发艺术探索之 android 的消息机制

提到消息机制读者应该都不陌生……从开发角度来讲, Handler 是 Android 消息机制的上层接口,这使得在开发过程当中只须要和 Handler 交互便可。……经过它能够轻松将一个任务切换到 Handler 所在的线程中去执行。java

正如开篇词所说,“主线程中不能进行网络通讯等耗时操做,而子线程中不能进行 UI 更新”,是我在 android 开发入门遇到的第一个知识点(keng),但当时只是单纯记忆,本篇将顺着开发艺术探索的讲述,梳理 android 的消息机制有关知识。android

###开篇知识小点 Handler 是 Android 消息机制的上层接口,使用场景一般是更新 UI。 Android 消息机制主要指 Handler 的运行机制,Handler 的运行须要底层的 MessageQueue 和 Looper 的支持。数组

  • MessageQueue:消息队列,内部存储一组消息,以队列形式对外提供插入和删除的工做,但其内部实现并不是队列,而是单链表的数据结构实现的,是一个消息的 存储单元,不能主动处理消息。
  • Looper:消息循环,以无限循环的形式查找是否有新消息,有的话就处理,不然等待。
  • ThreadLocal:Looper中的一个特殊概念,做用是能够在不一样线程中互不干扰地存储数据。Handler 建立的时候须要采用当前进程的 Looper 来构造消息循环系统,此时经过 ThreadLocal 能够轻松获取每一个线程的 Looper。

注意:线程是默认没有 Looper 的,若是须要使用 Handler 就必须为线程建立 Looper。主线程,即UI线程,是 ActivityThread ,ActivityThread 被建立时就会初始化Looper,因此主线程中默承认以使用 Handler。安全

###概述 几乎全部的 Android 开发者都知道在 Android 中访问 UI 只能在主线程中进行。CheckThread() 方法会对线程调用 UI 操做的正确性作出验证,若是当前访问 UI 的线程并不是主线程,则会抛出异常。 但, Android 建议不要在主线程使用耗时操做,以避免致使程序没法响应,即ANR。在开发工做中,咱们经常会遇到须要从服务端拉取信息,并在 UI 中进行显示。Handler 的存在就是为了解决在子线程中没法访问 UI 的矛盾。网络

  • 为何在子线程中不容许访问 UI 呢?由于 Android 的 UI 控件并不是线程安全的,若是多线程并发访问会致使 UI 控件处于不可预期的状态。 *为何不加锁?缺点有:1.加锁会致使 UI 访问逻辑变得复杂,其次锁机制会下降 UI 访问的效率,由于锁机制会阻塞某些线程的执行。

* Handler的简单使用

方法书里没有介绍,翻出萌新笔记贴一点: 简单应用:数据结构

private Handler handler = new Handler() {
 public void handleMessage(Message msg) {
            switch (msg.what) {
                case UPDATE_TEXT:
                    // 在这里能够进行UI操做
                   break;
                default:
                    break;
            }
        }

    };
复制代码
//在须要耗时操做的地方,开子线程
new Thread(new Runnable() {
    @Override
    public void run() {
//能够进行耗时操做
        Message message = new Message();
        message.what = UPDATE_TEXT;
        handler.sendMessage(message); //将Message对象发送出去
        }
    }).start();
复制代码

过程以下:多线程

  1. 首先在主线程中建立一个 Handler 对象,并重写HandleMessage方法
  2. 在子线程中须要进行 UI 操做的时候建立一个 Message 对象,
  3. 经过 Handler 将信息发送出去,
  4. 该信息被添加到 MessageQueue 中等待被处理,Looper 则会一直尝试从 MessageQueue 中取出待处理信息,最后分配到 Handler 的handleMessage() 方法中。

注意:在Activity中,并无显式调用 Looper.prepare() 和Looper.loop() 方法,由于在 Activity 的启动代码中,已经在当前 UI 线程调用了Looper.prepare() 和 Looper.loop() 方法,这就是前文提到 UI 线程默承认以使用 Handler 的缘由。 runOnUiThread() 是一个异步消息处理机制的接口封装,用法简单但实际原理是同样的。并发

Handler 的工做原理

Handler 建立时会采用当前线程的 Looper 来构建内部消息循环系统,若是当前线程没有 Looper ,那么就会报错。 解决方法:为当前线程建立 Looper ,或者在一个有 Looper 的线程中建立 Handler Handler 建立完毕以后,其内部的 Looper 以及 MessageQueue 就能够和 Handler 一块儿协同工做了,而后经过 Handler 的 post 方法将一个 Runnable 投递到 Handler 内部的 Looper 中处理,也可经过 Handler 中的 send 发送消息,一样在 Looper 内处理。post 的本质也是调用 send 。工做过程如图: app

Handler 工做过程.png
当 send 方法被调用,它会调用 MessageQueue 的 enqureMessage 方法将这个消息放入消息队列,由 Looper 处理,最后消息中的 Runnable 或者 Handler 的 handlerMessage 方法会被调用。Looper 是运行在建立 Handler 所在的线程中的,这样一来, Handler 中的业务逻辑就会被切换到建立 Handler 所在的线程中执行,完成切换线程的目的。

Android 的消息机制全面分析

ThreadLocal

一个线程内部的数据存储类,经过它能够独立存储指定线程中的数据。平常开发中较少用到,可是 android 源码中有时会利用它实现一些看似复杂的问题。less

  1. 通常来讲,当某些数据是以线程为做用域而且不一样线程有不一样的数据父本的时候,就会使用 ThreadLocal。好比 Handler,须要获取当前线程的 Looper ,且 Looper 做用域为线程,不一样线程间的 Looper 互相独立,这时候使用 ThreadLocal 则能够轻松实现 Looper 在线程中的存取。 不然,系统必须提供一个全局的哈希表供 Handler 查找指定线程的 Looper,就必须存在相似于 LooperManage 这样类,会使机制变得复杂。
  2. 可用于复杂逻辑下的对象传递,好比监听器传递。当函数调用栈比较深的时候,若是把监听器做为参数传递,会使程序设计变得糟糕;若是把监听器做为静态变量供线程访问,则基本不具有扩展性。而使用 ThreadLocal ,每一个线程都将拥有本身的监听器,能够在线程内全局,一键 get 到。 书上举了简单例子及源码,说明 ThreadLocal 在各个线程的数据存储独立性,由于例子较简单而源码部分比较繁琐,这里再也不赘述。总之,不一样线程访问 ThreadLocal 的 get 方法, ThreadLocal 将从各线程内部取出一个数组,按照当前线程的索引,查找相应的 value 值,因此线程不用,值不一样。从源码分析可得, ThreadLocal 的 set 和 get 方法都仅能访问当前线程的 localValue 对象的 table 数组,所以在不一样数组中访问同一个 ThreadLocal 的 set 和 get 方法能够互不干涉。 ###MessageQueue 前文已提过,消息队列实际上内部是用单链表实现的,包含两大重要方法, enqueueMessage 和 next 。
  • enqueueMessage 源码
// android SDK-27

    boolean enqueueMessage(Message msg, long when) {
      ...
        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();
            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 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.
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        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 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) {
                    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.
                        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;
        }
    }
复制代码

###Looper源码解析 在构造方法中建立一个 MessageQueue ,而后将当前线程对象保存起来。

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

经过Looper.prepare() 便可手动当前线程建立一个 Looper, 接着经过 Looper.loop() 开启循环。 Looper 提供了 quit 和 quitSafely 两种方法退出 Looper,前者直接退出,后者设定一个安全标记,等消息队列内全部消息处理完毕以后才会安全退出。若是在子线程里手动建立了 Looper 在全部消息完成以后应该调用 quit 方法,不然这个子线程会一直处在等待状态。

  • loop 方法
public static void loop() {
        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;

        // 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 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
            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 {
                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();
        }
    }
复制代码

loop 方法是一个死循环,惟一跳出死循环的条件是 MessageQueue.next 方法返回 null 。当 Looper.quit 被调用,Looper 调用 MessageQueue.quit 或者 quitSafely 方法通知消息队列退出。next 是一个阻塞方法,若是未接到新消息将一直等待,若是接到新消息,则交给 dispatchMessage 处理,这个方法是在 handler 建立的 Looper 中执行的。 ###Handler 的工做原理 ####发送消息的典型过程

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

public final boolean sendMessageDelayed(Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }


public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        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);
    }

rivate boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
复制代码

也就是说,Handler 调用 sendMessage 方法,依次调用 sendMessageDelayed,sendMessageAtTime,enqueueMessage 方法后,调用 queue.enqueueMessage 向消息队列插入了一条消息,接下来,按上文分析, Looper 中调用 MessageQueue.next 方法获得消息,最后将消息交给 Handler.dispatchMessage 处理。 实现以下:

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
复制代码

Handler 处理消息过程以下:

  1. 检查 Message callback 是否为 null,不为 null 则经过 handleCallback 来处理消息,Message 的 callback 是一个 Runnable 对象,实际上就是 Handler 的 post 方法传递的 Runnable 参数。
private static void handleCallback(Message message) {
        message.callback.run();
    }
复制代码

2.检查 mCallback 是否为 null ,不为 null 就调用 mCallback 的 handlerMessage 方法

/** * Callback interface you can use when instantiating a Handler to avoid * having to implement your own subclass of Handler. * * @param msg A {@link android.os.Message Message} object * @return True if no further handling is desired */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }
复制代码

经过Callback 能够采用Handler handler = new handler(callback)的方式建立 Handler 对象。callback 的意义在于能够建立一个 Handler 实例但不须要派生 Handler 的子类。在平常开发中,最多见的方式就是派生一个 Handler 的子类而且重写 handlerMessage 方法,当不想用该方式的时候能够采用 callback 实现。

Handler 消息处理.png

###主线程的消息循环 在主线程的入口方法中国,调用 Looper.prepareMainLooper() 来建立主线程的 Looper 以及 MessageQueue,并经过调用 Looper.loop() 来开启循环。

public static void main(String[] args) {
     ……
        Process.setArgV0("<pre-initialized>");
         Looper.prepareMainLooper();

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

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

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

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
复制代码

主线程消息循环开始以后,ActivityThread 还须要 Handler 来和消息队列进行交互,这个 Handler 就是 AcitivityThread.H。 ActivityThread 经过 Application Thread 和 AMS 进行进程间通讯,AMS以进程间通讯的方式完成 ActivityThread 的请求后会回调 ApplicationThread 中的 Binder 方法,而后 ApplicationThread 会向 H 发消息,H 收到消息后将 ApplicationThread 中的逻辑切换到 ActivityThread 中执行,即切换到主线程中去执行。

相关文章
相关标签/搜索