前言

Handler是安卓开发中我们常用的,主要用于线程之间的通讯,本文通过handler的几个常用方法来分析下具体的源码实现

常规操作

//创建消息
   Message msg = Message.obtain();
   msg.what=101;
   msg.obj="send message";
//发送消息
   mHandler.sendMessage(msg);
//接受消息
   private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            LogUtils.LogE(msg.toString());
        }
    };

这种写法是我们用的最多的写法,下面来具体介绍它的实现原理

主要方法

• 无论是sendMessage或sendMessageDelayed，sendEmptyMessageDelayed最终调用的方法都是sendMessageAtTime方法,sendMessageAtTime调用的是MessageQueue中的enqueueMessage方法,下面是核心代码:

//MessageQueue中:
    boolean enqueueMessage(Message msg, long when) {
       //省略片段代码
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                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;
            }
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

• MessageQueue类似于链表结构
• if (p == null || when == 0 || when < p.when):p为等待执行的message队列when为我们传入delay的时间值如果mMessages对象为空，或者when为0也就是立刻执行，或者新消息的when时间比mMessages队列的when时间还要早
• 符合以上一个条件就把新的msg插到mMessages的前面 并把next指向它,也就是msg会插进队列的最前面，等待loop的轮询
• 如果上述所有条件都不符合就进入else
• else中是一个死循环,when是指新消息的执行时间,p.when是指队列中message消息的执行时间
• 如果新消息的执行时间比队列里面的消息执行时间早就跳出循环,执行 msg.next = p;prev.next = msg,也就是插入到队列前面先执行它

Handler怎么与looper还有MessageQueue关联的呢?

在ActivityThread.main() 方法中有如下代码：

public static void main(String[] args) {
      //省略若干代码
        Looper.prepareMainLooper();
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        Looper.loop();
    }

• 原来在 ActivityThread 里 调用了 Looper.prepareMainLooper() 方法创建了 主线程的 Looper ,并且调用了 loop() 方法，所以我们就可以直接使用 Handler 了

     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与当前线程进行绑定，prepare方法不能调用二次,这也代表了一个线程只能有一个looper

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

• 这里MessageQueue是与当前的looper关联
  最后调用loop方法不断去轮询MessageQueue中的消息

    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;
            }
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            if (slowDispatchThresholdMs > 0) {
                final long time = end - start;
            }
            final long newIdent = Binder.clearCallingIdentity();
            msg.recycleUnchecked();
        }
    }

• me为 null就抛出异常,也就是必须先调用prepare方法后才能调用loop方法
• 不管什么Handler在什么线程发消息,接受消息的线程都是Looper.loop()所调用的线程
• 拿到looper中的队列进入死循环
• 不断取出消息,如果没有消息就return
• 最后调用msg.target.dispatchMessage也就是Handler来分发消息

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

• msg 没有 callback 的话，那么将会判断 mCallback 是否为空，这个 mCallback 就是构造方法种传递的那个 Callback,优先执行
• 如果 mCallback为空,那么就调用 Handler 的 handleMessage(msg) 方法，否则就调用 mCallback.handleMessage(msg) 方法，然后根据 mCallback.handleMessage(msg)的返回值判断是否拦截消息，如果拦截(返回 true)
• mCallback.handleMessage(msg)返回true,Handler的handleMessage将不会调用

问题&解答

主线程为什么不用创建Looper?

• 因为在ActivityThread.main()方法中已经把Looper给我们创建好了并且调用了loop方法
• 所有我们在主线程使用handler不用调用Looper,handleMessage回调在主线程(Looper.loop()方法在主线程)

子线程怎么使用Handler?

      new Thread(){
            @Override
            public void run() {
                Looper.prepare();
                Handler handler = new Handler(){
                    @Override
                    public void handleMessage(Message msg) {  }
                };
                handler.sendEmptyMessage(11);
                Looper.loop();
            }
        }.start();

• 必须调用Looper.prepare()再调用 Looper.loop()方法轮询消息,否则会抛出 RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.")

handler#postRunnable方法是在新的线程吗?

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

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

• post方法最终调用的都是这个方法,把Runnable赋值给Message.callback
• 最终走到handleMessage方法中调用handleCallback方法即调用post方法里传递的 Runnable 对象的run()方法
• 总结:只是一个回调方法与线程无关

handler内存泄漏?

8A0FV6H37~OR4_$R2~DCUEP.png

• 这是我们使用handler常见的警告提醒,原因是内部类持有外部类引用，从而外部类销毁时不能被回收而导致内存泄漏

解决方法

• 在onpause方法中removeCallbacksAndMessages(null),移除消息
• 使用static加弱引用的方法

    private static class MyHandler extends Handler {
        private WeakReference<StudyActivity> mReference;
        public MyHandler(StudyActivity activity) {
            mReference = new WeakReference<StudyActivity>(activity);
        }
        @Override
        public void handleMessage(Message msg) {
            StudyActivity activity = mReference.get();
            if (activity != null) {
                LogUtils.LogE(msg.what);
            }

        }
    }

总结

• Handler 的创建需要先调用 Looper.prepare() ，然后再手动调用 loop()方法开启循环
• App 启动时会在ActivityThread.main()方法中创建主线程的 Looper ,并开启循环，所以主线程使用 Handler 不用调用looper
• Callback.handleMessage() 的优先级比 Handler.handleMessage()要高
• Handler.post(Runnable)传递的 Runnale 对象并不会在新的线程执行
• 可以通过removeCallbacksAndMessages(null)或者静态类加弱引用的方式防止内存泄漏
• handlermessage回调是在Looper.loop()所在线程