Handler机制之Looper源码解析

拼搏现实的明天。 2022-05-11 01:20 207阅读 0赞

**Looper类**

> 为一个线程执行循环取出Message的类。

**异步线程和Handler与Looper的使用案例**

class LooperThread extends Thread {
          public Handler mHandler;
    
          public void run() {
             //开始创建Message队列
             Looper.prepare();
              mHandler = new Handler() {
                 public void handleMessage(Message msg) {
                     //处理传递过来的Message
                 }
              };
             //会循环调度MessageQueue中message
             Looper.loop();
         }

**Looper类源码分析**

从构造器和属性开始分析：

//ThreadLocal 线程局部变量，会为每一个线程都创建副本。
       static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
       //主线程的looper
       private static Looper sMainLooper; 
       //当前运行线程上的Message队列
        final MessageQueue mQueue;
        //当前运行的线程
        final Thread mThread;
        
        //构造器 ,quitAllowed：该线程的Message队列是否允许退出。
        private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed);
            //获取当前运行的线程
            mThread = Thread.currentThread();
        }

来看下`Looper.prepare()`：开始创建线程的Looper和MessageQueue

public static void prepare() {
            prepare(true);
        }
        private static void prepare(boolean quitAllowed) {
            //当前线程的局部Looper已经存在
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            //将Looper存到当前线程的ThreadLocal变量中
            sThreadLocal.set(new Looper(quitAllowed));
        }

接下来，看`Looper.loop()`:

public static void loop() {
            //获取到当前线程的Looper
            final Looper me = myLooper();
            if (me == null) {
                //调用Looper.loop()方法之前，必须调用prepare()，否则会抛异常
                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
            }
            final MessageQueue queue = me.mQueue;
            //确保线程的标示identity是本地进程的标示
            Binder.clearCallingIdentity();
            final long ident = Binder.clearCallingIdentity();
            //一直循环
            for (;;) {
                //MessageQueue.next()会阻塞，则会进行等待状态
                Message msg = queue.next(); 
                if (msg == null) {
                    //当Message队列中没有message，该队列已经停止，跳出for循环
                    return;
                }
    
                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 {
                   //调用message中目标Handler的dispatchMessage()
                    msg.target.dispatchMessage(msg);
                    end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
                } finally {
                    if (traceTag != 0) {
                        Trace.traceEnd(traceTag);
                    }
                }
                msg.recycleUnchecked();
            }
        }

从上可知： `loop()`方法的逻辑包含：开始执行线程message队列,会将message传递`Handler.dispatchMessage()`

接下来，看一下有关于主线程的looper的相关方法：

public static void prepareMainLooper() {
            //主线程的Message队列不允许退出，设置为false.
            prepare(false);
            synchronized (Looper.class) {
                if (sMainLooper != null) {
                    throw new IllegalStateException("The main Looper has already been prepared.");
                }
                sMainLooper = myLooper();
            }
        }
        /**
         * 返回程序主线程的Looper.
         */
        public static Looper getMainLooper() {
            synchronized (Looper.class) {
                return sMainLooper;
            }
        }

实际上开发中，只需要调用`getMainLooper()`可以获取到主线程的Looper.  
然而`prepareMainLooper()`又是在哪里调用的呢？

经过查找源码,发现**ActivityThrad类**中的`main()`方法:

public static void main(String[] args) {
            Looper.prepareMainLooper();
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
            if (sMainThreadHandler == null) {
                sMainThreadHandler = thread.getHandler();
            }
            Looper.loop();
        }

从上可知：程序进程一创建，就开始初始过主线程的Looper,且开始循环调用主线程中Message。

最后，再来了解一下如何停止一个带有消息队列的线程：

public void quit() {
            mQueue.quit(false);
        }
        //android 高版本中调用
        public void quitSafely() {
            mQueue.quit(true);
        }

Looper的停止调度，会调用MessageQueue的停止方法，会让MessageQueue中的Message返回为空，最终导致跳出在Looper.loop()中的for循环。