android分析之消息处理

前序:每个APP对应一个进程,该进程内有一个ActivityThread的线程,称为主线程(即UI主线程),此外,还有其他线程,这个再论。

 

android的消息系统分析。

  1. 每个Thread只对应一个Looper
  2. 每个Looper只对应一个MessageQueue
  3. 每个MessageQueue中有N个Message
  4. 每个Message中最多指定一个Handler来处理事件
  5. 一个Thread可以对应多个Handler

Looper负责从消息队列中(MessageQueue)取出消息(Message/Runnable),交给Handler来处理。

 

Message:

public final class Message implements Parcelable {

public int what;//每个Message可以指定一个Handler,由于可以存在多个Handler,用what来标识具体的Handler public int arg1; public int arg2; public Object obj; public Messenger replyTo; /*package*/ static final int FLAG_IN_USE = 1 << 0; /*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1; /*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE; /*package*/ int flags; /*package*/ long when; /*package*/ Bundle data; /*package*/ Handler target;//指定由哪个Handler来处理本Message /*package*/ Runnable callback; /*package*/ Message next;//消息链 private static final Object sPoolSync = new Object(); private static Message sPool;//消息链表的头,注意是static private static int sPoolSize = 0; private static final int MAX_POOL_SIZE = 50;

......

}

 

MessageQueue实际上是对Message的一种操作的封装,真正的消息队列是以sPool为首的消息链表:

public class MessageQueue {
    // True if the message queue can be quit.
    private final boolean mQuitAllowed;

    @SuppressWarnings("unused")
    private int mPtr; // used by native code

    Message mMessages;//消息...
    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
    private IdleHandler[] mPendingIdleHandlers;
    private boolean mQuiting;

    // Indicates whether next() is blocked waiting in pollOnce() with a non-zero timeout.
    private boolean mBlocked;

    // The next barrier token.
    // Barriers are indicated by messages with a null target whose arg1 field carries the token.
    private int mNextBarrierToken;

//调用Native函数做真正的处理 private native void nativeInit(); private native void nativeDestroy(); private native void nativePollOnce(int ptr, int timeoutMillis); private native void nativeWake(int ptr);
......

}

 

  Looper:

public class Looper {
    private static final String TAG = "Looper";

    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();//与线程相关的模板类
    private static Looper sMainLooper;  //static类型,只有一个

    final MessageQueue mQueue;//Looper持有的MessageQueue
    final Thread mThread;
    volatile boolean mRun;

    private Printer mLogging;

......

}

  

Handler:

public class Handler{//真正对处理Message的类:包括处理Message和将消息压到MessageQueue队列里

    final MessageQueue mQueue;
    final Looper mLooper;
    final Callback mCallback;
    IMessenger mMessenger;

...

}

  

Looper的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;

        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
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);//调用消息指定的接收者Handler来处理它

            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.recycle();//丢弃消息,循环再利用
        }
    }

  Handler取消息,每次从sPool(Message里的static Message类型)取出一个Message,其调用的是static方法:

    public static Message obtain(Handler h, int what, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.obj = obj;

        return m;
    }

  Handler将消息压入消息队列:

    public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            msg.target = this;
            sent = queue.enqueueMessage(msg, uptimeMillis);//调用MessageQueue的方法执行压入操作
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

  小结:Handler取消息是直接取(从sPool里),将消息压入MessageQueue是调用MessageQueue的方法。

----------------------------------------------分割线----------------------------------------------------------------------------

下面分析这些对象都是在什么时候创建的。

Looper是什么时候创建的?

每个线程都只有一个Looper对象。

1.普通线程(非主线程)

一个典型的自己创建的线程使用Looper如:

class LooperThread extends Thread{
    public Handler mHandler;
    public void run(){
        Looper.prepare();
        mHandler= new Handler(){
                public void handleMessage(Message msg){
                    //处理消息
                }
        };
        Looper.loop();//进入消息循环
    }
}

  那么Looper是在什么时候创建的呢?看Looper.prepare()方法:执行完这个方法,就得到了一个本线程独有的Looper。

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();//这是一个与线程先关的模板类    

private static void prepare(boolean quitAllowed) { if (sThreadLocal.get() != null) {//若调用者所在宿主线程已经有Looper,则抛出异常 throw new RuntimeException("Only one Looper may be created per thread"); } sThreadLocal.set(new Looper(quitAllowed));//Java中的线程局部存储,即不同线 }//程都通过sThreadLocal得到自己的不同的Looper对象引用

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);//创建Looper要处理的消息队列
        mRun = true;
        mThread = Thread.currentThread();//得到当前线程
    }

  

  那么Handler是如何与Looper关联起来的呢?看Handler的构造方法:

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

        mLooper = Looper.myLooper();//通过线程局部存储,获得本线程的Looper
        if (mLooper == null) {
            throw new RuntimeException(
                "Can‘t create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = null;
    }
    public static Looper myLooper() {//获取与本线程相关的Looper
        return sThreadLocal.get();
    }

  

  小结:每个线程都通过sThreadLocal<Looper>来创建一个Looper(进而创建一个MessageQueue),再创建一个Handler(通过sThreadLocal),从而将Handler与Looper“绑定”在一起,形成一个完整的消息循环系统。

 

2.主线程ActivityThread

主线程是什么时候创建Looper的?在ActivityThread.java的main方法里有:

    public static void main(String[] args) {
        SamplingProfilerIntegration.start();
        CloseGuard.setEnabled(false);

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

        Looper.prepareMainLooper();//也是sThreadLocal.set(new Looper(quitAllowed))来创建一个线程所属的Looper,并通过sThreadLocal.get()将Looper赋给sMainLooper(private static Looper sMainLooper),sMainLooper的作用就是,其他线程可以获取到主线程的Looper(因为sMainLooper是static,在主线程中赋值的)。
        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"));
        }

        Looper.loop();

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

  

Looper.loop()是一个static的方法,作为消息循环处理器,不断的取消息,分发消息。

 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。