Android异步消息处理机制:Looper、Handler、Message

1 简介

Handler,Looper,Message这三者都与Android异步消息处理线程相关,

Looper:负责创建一个MessageQueue,然后进入一个无限循环体不断从该MessageQueue中读取消息;

Handler:消息创建者,一个或者多个

2 源码解析

 2.1 Looper

        Looper主要方法就是:prepare()和loop()两个方法:

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

 sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量,通过上述代码知道,一个Looper实例被放入了ThreadLocal,并且判断sThreadLocal是否为null,否则抛出异常,说明Looper.prepare()方法不能被调用两次,同时也保证了一个线程中只有一个Looper实例。

下面看Looper的构造方法

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

在消息队列中,创建MessageQueue(消息队列)

• 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 traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            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();
        }
    }

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

如何me == null,则直接抛出异常,也就是说looper方法必须在prepare方法之后运行

第14行,取出一条消息,如果没有消息则阻塞

第32行,msg.target.dispatchMessage(msg); 把消息交给msg的target的dispatchMessage方法处理,Msg的target是什么?其实就是Handler对象 

第54行,释放消息占用的资源

Looper主要作用

1.与当前线程绑定,保证一个线程只有一个Looper实例,同时一个Looper实例只有一个MessageQueue;

2.loop()方法,不断从MessageQueue中去取消息,交给消息target属性的dispatchMessage去处理;

 

2.2 Handler

    首先看Handler构造方法,看其如何与MessageQueue联系的,他在子线程中发送的消息(一般发送消息都在非UI线程),如何发送到MessageQueue中去的。

public Handler(boolean async) {
        this(null, async);
    }
   public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> 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 that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

第15行:通过Looper.myLooper()获取当前线程保存的Looper实例;

第20行:通过Looper实例中保存的MessageQueue(消息队列),这样就保证了handler的实例与我们Looper实例中MessageQueue关联上。

sendMessage方法

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

sendEmptyMessageDelayed方法

 public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

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

多次跳转之后到sendMessageAtTime方法,此方法中调用了enqueueMessage方法

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

enqueueMessage中首先为msg.target赋值this,[Looper的loop方法取出每个msg,然后交给msg.target.dispatchMessage(msg)去处理消息],也就是爸当前的handler作为msg的target属性。最终调用queue.enqueueMessage的方法,说明handler发出的消息,最终保存到消息队列中去了。

过程:Looper调用prepare()和loop()方法,在当前执行的线程中保存一个Looper实例,这个实例保存一个MessageQueue对象,然后当前线程进入一个无限循环中去,不断从MessageQueue中读取Handler发来的消息,然后在回调创建这个消息的handler中的dispatchMessage方法

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

第10行:调用handleMessage(msg),这个方法空实现:

/**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }

可以看到这是一个空方法，因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理。

总结:

1.首先Looper.prepare()在本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象;因为Looper.prepare(0在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个;

2.Looper.loop()会让当前线程进入一个无限循环,不断从MessageQueue的实例中读取消息,然后回调msg.target.dispatchMessage(msg)方法;

3.Handler的构造方法,会首先得到当前线程中保存的Looper实例,进而与Looper实例中的MessageQueue相关联;

4.Handler的sendMessage方法,会给msg的target赋值为handler自身,然后加入MessageQueue;

5.在构造Handler实例时,我们会重写handleMessage方法,也就是msg.target.dispatchMessage(msg)最终调用的方法.

2.3 Handler post

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

可以看到在getPostMessage中,得到了一个Message对象,然后将我们创建的Runnable对象作为callback属性,赋值给message

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

最终和handler.sendMessage一样,调用了sendMessageAtTime,然后调用了enqueueMessage方法,给msg.target赋值为handler,最终加入MessageQueue.