Android的消息机制

前言

Android 的消息机制原理是Android进阶必学知识点之一,在Android面试也是常问问题之一。在Android中,子线程是不能直接操作View,需要切换到主线程进行。那么这个切换动作就涉及到了Android的消息机制,也就是本文要讲的Handler、Looper、MessageQueue、Message它们之间的关系。

Handler

Handler在消息机制中扮演发送消息处理消息的角色,也是我们平常接触最多的类。

Handler如何处理消息?

下面代码展示Handler如何处理消息。新建Handler对象,并重写handleMessage,在方法内处理相关逻辑,一般处理和主线程相关的逻辑。Handler有很多的构造器,下面构造器常用在主线程。

  private Handler handler=new Handler(){
        @Override
        public void handleMessage(Message msg) {
            if (msg.what==1){
                Toast.makeText(MainActivity.this,"handle message",Toast.LENGTH_LONG).show();
            }
            
        }
    };
    

Handler是如何发送消息的呢?

通过下面的代码可以了解到,Handler对象支持发送MessageRunable。Runable最终被包装成Messagecallback实例变量(Handler对象处理消息会优先处理callback的逻辑),和Message一样的方式放到消息队列中。而每个方法都有相关的变形,支持延迟发送,或者未来的某段时间里发送等等。

    //在消息池获取消息体,能达到消息重用,如果消息池没有消息,则新建消息
        Message msg = handler.obtainMessage();
        msg.what = 1;
        //发送消息
        handler.sendMessage(msg);
        //发送空消息,参数会自动被包装msg.what=1
        handler.sendEmptyMessage(1);
        //未来的时间里发送消息
        handler.sendEmptyMessageAtTime(1, 1000);
        //延迟发送消息
        handler.sendEmptyMessageDelayed(1, 1000);

        msg = handler.obtainMessage();
        msg.what = 2;
        //将消息发送消息队列前面
        handler.sendMessageAtFrontOfQueue(msg);
        //发送任务,run方法内容将handler被处理。
        handler.post(new Runnable() {
            @Override
            public void run() {
                Log.i("Handler", "Runnable");
            }
        });

如果平常使用,我们只需要主线程定义Hanlder处理消息的内容,在子线程发送消息即可达到切换流程。

Looper

Looper负责循环的从消息队列中取消息,发送给Handler处理。因为消息队列只用来存储消息,所以需要Looper不断的从消息队列中取消息给Handler。默认情况,所有线程并不拥有Looper。如果在子线程直接执行Looper.loop方法,就会发生异常。那主线程为什么不会报错?在App的启动流程中,创建ActivityThread时,会调用Looper.prepare来创建LooperMessageQueue,和Looper.loop开启循环。也就是系统为我们在主线程创建LooperMessageQueue。所以,在子线创建Handler前,需要先调用Looper.prepare方法,创建LooperMessageQueueIntentService就是这样实现的。点击看IntentService的知识点。

MessageQueue

MessageQueue内部是以链表的形式组织的,主要作用是存储Message。在创建Looper的时候,会自动创建MessageQueue

三者关系形成了Android的消息机制

Handler发送消息时会将消息插入到MessageQueue,而Looper不断的从MessageQueue中取消息分发给Handler处理。

源码解析

Handler的构建

我们先看一下Handler的构造器代码。

    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());
            }
        }
        //分析一
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        //分析二
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
    

Handler有很多重载的构造器,我们常用在使用默认构造器,最终会调用上面的构造器。

分析一

通过Looper.myLooper(),获Looper的实例。而在myLooper的实现中,是通过ThreadLocalget方法来获取的。如果ThreadLocal不存在Looper,则放回nullThreaLocal这里可以简单理解为保存当前线程私有独立的实例,其他线程不可访问。如果ThreadLocal不存在Looper实例则,返回null。这也就是前面说的,在子线程创建Handler前,需要先调用Looper.prepare方法。否则会抛出RuntimeException

 public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

分析二

mQueueLooper中的消息队列,mCallBack定义了一个接口,用于回调消息处理。

  public interface Callback {
        /**
         * @param msg A {@link android.os.Message Message} object
         * @return True if no further handling is desired
         */
        public boolean handleMessage(Message msg);
    }

Handler发送消息

Handler所有发送消息方法的变体最终都会以下面方法放去到消息队列中。

    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);
    }

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

这里最重要的就是enqueueMessage方法中,将当前Handler对象设置给Messagetarget变量。然后调用队列queueenqueueMessage方法。

    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.");
        }

        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;
            //如果队列为空或者插入message未来处理时间小于当前对头when
            //则将当前消息设为队列头
            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 {
                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;
    }

而在MessageQueueenqueueMessage方法中,会先检查target是否nullmessage是否应在使用,当前线程是否退出,死亡状态。如果是,则抛出异常。如果当前队列是空或者阻塞,直接当前Message对象设为队列的头并唤醒线程。如果不是,则根据Message对象的when插入到队列合适的位置。因此可以看得出,Handler发送消息时是将消息放到队列中。

Looper和MessageQueue的创建

前面讲过,子线程使用Handler,需要调用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");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

如果当前线程已经有Looper,代用Looper就会报错。如果没有,new Looper并保存到ThreadLocal中。new Looper非常简单,只是新建一个MessageQueue,和持有当前线程。

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

Looper是如何实现循环的

在调用了Looper.prepare创建LooperMessageQueue对象后,要调用Loop.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();

        // Allow overriding a threshold with a system prop. e.g.
        // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
        final int thresholdOverride =
                SystemProperties.getInt("log.looper."
                        + Process.myUid() + "."
                        + Thread.currentThread().getName()
                        + ".slow", 0);

        boolean slowDeliveryDetected = false;
        //分析一
        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 traceTag = me.mTraceTag;
            long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
            long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
            if (thresholdOverride > 0) {
                slowDispatchThresholdMs = thresholdOverride;
                slowDeliveryThresholdMs = thresholdOverride;
            }
            final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
            final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

            final boolean needStartTime = logSlowDelivery || logSlowDispatch;
            final boolean needEndTime = logSlowDispatch;

            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }

            final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
            final long dispatchEnd;
            try {
                //分析二:
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            if (logSlowDelivery) {
                if (slowDeliveryDetected) {
                    if ((dispatchStart - msg.when) <= 10) {
                        Slog.w(TAG, "Drained");
                        slowDeliveryDetected = false;
                    }
                } else {
                    if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                            msg)) {
                        // Once we write a slow delivery log, suppress until the queue drains.
                        slowDeliveryDetected = true;
                    }
                }
            }
            if (logSlowDispatch) {
                showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", 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();
        }
    }

分析一:
通过无限制的for循环,读取队列的消息。而MessageQueuenext方法内部通过链表的形式,根据when属性的顺序返回message

分析二:
调用Message对象的targetdipatchMessage方法。这里的target就是发送消息的Handler对象。而在Handler对象的dipatchMessage方法中,优先执行Message对象的callback方法,即优先执行我们发送消息时以Runable发送的任务,如果有的话。不然检测Callback对象的handleMessage方法,最后才是我们重写Hanlder对象的handleMessage方法。因为Handler不仅有默认构造函数,还有可以传入Callback,Looper等的构造函数。

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

Message的复用

通过handler.obtainMessage而不是new方式获得消息实例。因为obtainMessage方法会先检测消息池是否有可以复用的消息,没有再去new一个消息实例。下面是类Message的obtain方法。

public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

sPool的类型是Message,内部通过成员变量next,维护一个消息池。虽然叫消息池,内部却通过next不断的指向下一个Message,以链表维护的这个消息池,默认大小为50。在链表sPool不为空的情况,取表头Message元素,并将相关属性进行初始化。

那么Message对象是在什么时候被放进消息池中的呢?

Looperloop方法中,最后调用MessagerecycleUnchecked方法

void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

在同步代码块,可以看到,将sPool指向当前要被回收的Message对象,而Messagenext指向之前的表头。

总结

  1. 在子线程使用Handler,需要先调用Looper.prepare方法,再调用Looper.loop方法。
  2. 消息队列以链表的形式维护着,消息的存放和获取顺序根据when时间依次排列。
  3. 通过Handler,在子线程耗时操作,主线程更新UI。应用场景:IntentServiceHandlerTreadAsyncTack

知识点分享

HandlerThread必知必会

IntentService必知必会

如果觉得文章有用,给文章点个赞,铁子

你可能感兴趣的:(Android的消息机制)