Handler+Message+MessageQuque+Looper 异步加载类 消息处理机制 分析

其实在平时开发、面试、技术交流都会提到Android消息处理机制，记得有次去面试有问道，消息处理流程，我相信这个对于开发Android两年都很简单，但是具体问道每个类作用和具体回调机制，每个对象分布在那个线程里，这时候就有点不清楚了，我回来之后就详细研究了Handler、Message、MessageQueue、Looper,ActivityThread,总结如下：

一.对象描述

    1.应用程序启动在attach方法中加载ActivityThread线程管理类，在main()中调用looper循环读取消息队列.

     2.Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的Message Queue(消息队列)，消息处理机制核心功能就在Looper里面处理，Looper通过next操作先从MessageQueue取消息，然后通过disptchMessage方法通知Handler回传给

     3.Handler: 你可以构造Handler对象来与Looper沟通，以便push新消息到Message Queue里，或者接收Looper(从Message Queue取出)所送来的消息。
     4.Message Queue(消息队列)，用于管理消息队列，在Handler初始化的时候会创建一个Message Queue 对象和Looper对象。

二.应用启动一个Looper循环读取消息队列流程如下：

      

//在Activity中attach流程时，传入ActivityThread线程对象

final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config)

//在ActivityThread main中启动设置looper对象，并启动循环操作

 public static void main(String[] args) {
        /// M: Retrieve the information from AMS @{
        if ( args != null && args.length > 0 ) {
            if ( args[0].equals("enable") ) {
                mEnableAppLaunchLog = true;
            }
            if ( args[1].equals("true") ) {
                mIsUserBuild = true;
            }
            if ( args[2].equals("true") ) {
                mBooted = true;
            }
        }
        /// @}
        
        logAppLaunchTime(TAG, "ActivityThread is created"); /// M: It's for debugging App Launch time
        
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }

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

        AsyncTask.init();

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

        /// M: ALPS00270724 message history mechanism @{
        if (!"user".equals(android.os.Build.TYPE)) {
            Looper.myLooper().setMessageLogging(new MessageLogger());
        }
        /// @}
	//执行looper循环消息循环操作
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

三.讲向消息队列加入消息详细流程分析如下：

     下面我们先从Handler讲起，Handler是异步加载类，先从Handler初始化函数分析。

     

import android.util.Log;
import android.util.Printer;

import java.lang.reflect.Modifier;

public class Handler {
    /*
     * Set this flag to true to detect anonymous, local or member classes
     * that extend this Handler class and that are not static. These kind
     * of classes can potentially create leaks.
     */
    private static final boolean FIND_POTENTIAL_LEAKS = false;
    private static final String TAG = "Handler";
    final MessageQueue mQueue;
    final Looper mLooper;
    final Callback mCallback;
    IMessenger mMessenger;
    /**
     * Callback interface you can use when instantiating a Handler to avoid
     * having to implement your own subclass of Handler.
     */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }
    
    /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }
    
    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

    /**
     *
     *初始化Handler对象
     * 
     */
    public Handler() {
    	//Java反射机制来验证是不是Handler对象
        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());
            }
        }
      //获取本线程的looper对象,Looper.myLooper就是返回一个同步线程类
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        //初始化MessageQueue
        mQueue = mLooper.mQueue;
        mCallback = null;
    }

    /**
     * Constructor associates this handler with the queue for the
     * current thread and takes a callback interface in which you can handle
     * messages.
     */
    public Handler(Callback callback) {
        
    }

    /**
     * 由外部设置looper  
     * 
     */
    public Handler(Looper looper) {
       
    }

    /**
     * 由外部设置looper，和回调对象。
     * 
     */
    public Handler(Looper looper, Callback callback) {
    }

   
   
  
    /**
     * 
     * sendMessageAtTime是最终加入消息队列的方法，在设置时间戳后加入消息对象中，以时间戳为队列
     * uptimeMillis参数是时间戳，
     * Message 是消息对象，
     *
     *
     */
    public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
           //这个很关键，这个是指定消息回调对象，
            msg.target = this;
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

    /**
     * Enqueue a message at the front of the message queue, to be processed on
     * the next iteration of the message loop.  You will receive it in
     * {@link #handleMessage}, in the thread attached to this handler.
     * <b>This method is only for use in very special circumstances -- it
     * can easily starve the message queue, cause ordering problems, or have
     * other unexpected side-effects.</b>
     *  
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */
    public final boolean sendMessageAtFrontOfQueue(Message msg)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            msg.target = this;
            sent = queue.enqueueMessage(msg, 0);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

    /**
     * 从一个消息队列中删除一个消息
     * 
     */
    public final void removeMessages(int what) {
        mQueue.removeMessages(this, what, null);
    }

    final IMessenger getIMessenger() {
        synchronized (mQueue) {
            if (mMessenger != null) {
                return mMessenger;
            }
            mMessenger = new MessengerImpl();
            return mMessenger;
        }
    }

    private final class MessengerImpl extends IMessenger.Stub {
        public void send(Message msg) {
            Handler.this.sendMessage(msg);
        }
    }

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

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

    private static void handleCallback(Message message) {
        message.callback.run();
    }

    
}

四.讲Looper线程队列管理流程详解：

    

//Looper类分析
public class Looper {
   //static变量，判断是否打印调试信息。
    private static final boolean DEBUG = false;
    private static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV;

    // sThreadLocal.get() will return null unless you've called prepare().
//线程本地存储功能的封装，TLS，thread local storage,什么意思呢？因为存储要么在栈上，例如函数内定义的内部变量。要么在堆上，例如new或者malloc出来的东西
//但是现在的系统比如Linux和windows都提供了线程本地存储空间，也就是这个存储空间是和线程相关的，一个线程内有一个内部存储空间，这样的话我把线程相关的东西就存储到
//这个线程的TLS中，就不用放在堆上而进行同步操作了。
    private static final ThreadLocal sThreadLocal = new ThreadLocal();
//消息队列，MessageQueue，看名字就知道是个queue..
    final MessageQueue mQueue;
  
  
   
    /**
     *  Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
   //这个loop是在ActivityThread对象中main启动时调用loop方法
   //这个是static函数喔！

    public static final void loop() {
        Looper me = myLooper();//从该线程中取出对应的looper对象
        MessageQueue queue = me.mQueue;//取消息队列对象...
        while (true) {
            Message msg = queue.next(); // might block取消息队列中的一个待处理消息..
            //if (!me.mRun) {//是否需要退出？mRun是个volatile变量，跨线程同步的，应该是有地方设置它。
            //    break;
            //}
            if (msg != null) {
                if (msg.target == null) {
                    // No target is a magic identifier for the quit message.
                    return;
                }
                if (me.mLogging!= null) me.mLogging.println(
                        ">>>>> Dispatching to " + msg.target + " "
                        + msg.callback + ": " + msg.what
                        );
                msg.target.dispatchMessage(msg);
                if (me.mLogging!= null) me.mLogging.println(
                        "<<<<< Finished to    " + msg.target + " "
                        + msg.callback);
                msg.recycle();
            }
        }
    }
}