handler机制源码分析

最新推荐文章于 2022-06-25 23:46:00 发布

vvufaxianshi

最新推荐文章于 2022-06-25 23:46:00 发布

阅读量138

点赞数

文章标签： handler

本文链接：https://blog.csdn.net/vvufaxianshi/article/details/88077948

版权

为了避免ANR，我们会通常把耗时操作放在子线程里面去执行，但是子线程不能更新UI，所以当子线程需要更新的UI的时候就需要借助到android的消息机制，也就是Handler机制了，总的来说。Handler机制就是Handler 往 MessageQueue里边添加Message，然后 Looper.loop()无限循环读取消息，然后再调用 Handler 处理消息。主要涉及有4个类。Handler，MessageQueue，Message，Looper。

Handler

每一个 Handler 都和一个线程的 Looper 以及这个线程中的消息队列关联。
Handler 所做的就是 “线程切换”：在子线程将 Message 或者 Runnable 发送到 MessageQueue 中，然后等待 Looper 调度这个消息后，再召唤 Handler 来处理消息，这时消息已经在创建 Handler 的线程了
Handler 的属性如下：

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

可以看到 Handler 的属性很简单，其中 mCallback 可以作为构造函数的参数用于新建 Handler。

public Handler(Callback callback) {
    this(callback, false);
}
public interface Callback {
    public boolean handleMessage(Message msg);
}

我们平时创建 Handler 都是创建一个 Handler 的子类然后重写它的 handleMessage 方法，但是大家都知道这样会导致内存泄漏。
有了 Handler.Callback 接口我们可以用这种方式创建 Handler：

 Handler mHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        //这里处理消息
        return false;
    }
});

最终效果和创建 Handler 子类一样，但是不会导致内存泄漏。（handler 引用 Activity 阻止了GC对Acivity的回收，在Java中，非静态(匿名)内部类会默认隐性引用外部类对象。而静态内部类不会引用外部类对象。如果外部类是Activity，则会引起Activity泄露。当Activity finish后，延时消息会继续存在主线程消息队列中1分钟，然后处理消息。而该消息引用了Activity的Handler对象，然后这个Handler又引用了这个Activity。这些引用对象会保持到该消息被处理完，这样就导致该Activity对象无法被回收，从而导致了上面说的 Activity泄露。）
Handler 发送的主要有两种类型：Message和Runnable。
发送方法有 postXXX() 和 sendXXX() 两种，postXXX 发送的是 Runnable，调用的也是 sendXXX，而 Runnable 也会被转成 Message：

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

所以我们直接看 sendXXX 方法：

public final boolean sendMessage(Message msg){
    return sendMessageDelayed(msg, 0);
}
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

可以看到 Handler 发送消息最后还是调用了消息队列的 enqueueMessage() 方法

处理消息

/**
 * 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);
    }
}
private static void handleCallback(Message message) {
    message.callback.run();
}
public void handleMessage(Message msg) {
}

Handler 在处理消息时，会有三种情况：
1，msg.callback 不为空，这在使用 Handler.postXXX(Runnable) 发送消息的时候会发生，这就直接调用 Runnable 的 run() 方法
2，mCallback 不为空，这在我们使用前面介绍的 Handler.Callback 为参数构造 Handler 时会发生，那就调用构造函数里传入的 handleMessage() 方法，如果返回 true，那就不往下走了
3，最后就调用 Handler.handleMessage() 方法，这是一个空实现，需要我们在 Handler 子类里重写

由于发送时可以发送 Callback 和 Message，所以取消也有两种：
removeCallbacks()和removeMessages()
看一下源码发现调用的其实就是消息队列的出队方法：

public final void removeCallbacks(Runnable r){
    mQueue.removeMessages(this, r, null);
}
public final void removeMessages(int what) {
    mQueue.removeMessages(this, what, null);
}

Message

消息机制中要传递的就是 Message，官方对它的描述是：
包含任意类型的对象和描述信息，可以被发送给 Handler。Message的属性有message的标识(what)，数据的存储对象(arg1, Bundle等)，与之关联的Handler(target)等；

创建Message对象的时候，有三种方式：

1.	Message  msg1  =  new Message();
2.	Message  msg2  =  handler.obtainMessage();
3.	Message  msg3  =  Message.obtain();

这三种方式有什么区别呢？

第一种方法就是新建一个对象，没什么好说的。
第二种方法是return的Message.obtain()和第三种方法是一样的。

    public final Message obtainMessage(){
        return Message.obtain(this);
	}

第三种方法是优先从Message pool里边取message，如果取不到再新建Message，这样比较节约内存，所以建议使用后两种方法获取Message。

    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;//以链表的形式存储message
                m.next = null;
                m.flags = 0; // clear in-use flag //重置标志位
                sPoolSize--;
                /// M: Add message protect mechanism
                m.hasRecycle = false;
                return m;
            }
        }
        return new Message();
	}

Message.recycleUnchecked()是对消息回收利用的方法，将消息标志为正在使用，并清除其他详细信息，放入到消息池里边。

    void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE; 
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;
        hasRecycle = true;
        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {//将消息放入Message pool
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
}

MessageQueue

MessageQueue 管理着一个Message 的链表，Handlers 为它添加消息，Looper 从中取消息。

private final boolean mQuitAllowed;//表示MessageQueue是否允许退出
@SuppressWarnings("unused")
private long mPtr; //mPtr是native代码相关的
 
Message mMessages; //表示消息队列的头Head
private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;
private IdleHandler[] mPendingIdleHandlers;
private boolean mQuitting; //指出获取下一个消息的方法 next() 是否阻塞
 
// 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;　


MessageQueue 一般不直接访问，都是通过 Looper.myQueue() 方法获取一个消息队列。

消息队列在 Looper 的构造函数中初始化：

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}
MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}
MessageQueue 的构造函数中传入一个是否允许中途退出的标志，然后调用 Native 方法初始化。

消息入队的方法是 enqueueMessage() 方法：
boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) { //这里要求消息必须跟 Handler 关联
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {  //检查入队的消息是否在被使用，如果是的话会报错。
        throw new IllegalStateException(msg + " This message is already in use.");
    }

    synchronized (this) {
        if (mQuitting) {    //如果消息队列已经退出，还入队就报错
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

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

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

消息出队的方法是 MessageQueue.next() 方法：
next方法取出下一个Message（从头部取），如果没有Message可以处理，就可以处理下IdleHandler。
首先初始化2个接下来要用到的变量，紧接着进入无限for循环中，其某次循环主要做这么几件事情：

如果nextPollTimeoutMillis != 0的话，调用Binder.flushPendingCommands();
调用nativePollOnce(mPtr, nextPollTimeoutMillis);
进入一个大的同步块，尝试获取一个可以处理的消息，具体做法是，记录当前时间now，初始化变量prevMsg为null，msg为mMessges；

如果msg是一个sync barrier消息，则直奔下一个asynchronous消息（这之间的所有同步消息会被本次循环忽略，也就是说遇到这种情况，

next方法会从找到的异步消息的位置开始尝试获取一个可以处理的消息并返回），同时更新prevMsg，msg的值；

4.当退出此do…while循环的时候msg可能为空（走到队列尾了），或者成功找到了一个这样的（异步）消息。

5.如果是到队尾了即msg==null，则表示没更多的消息了，设置nextPollTimeoutMillis = -1;否则当now<msg.when（msg的时间还没到），设置一个合理的等待时间，即调用

nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);

6.当msg到了该处理的时间了，也就是说我们找到了这样一个消息可以返回了，设置mBlocked为false，将msg从mMessages队列中取出来（类似单链表的删除操作），并执行

msg.next=null、msg.markInUse()，返回msg。

7.如果到这一步了还没return的话，那说明还没有可以处理的消息，检查下队列是否要求退出了，如果是执行dispose()，返回null。当Looper的loop方法看到null的message的时候会退出loop。

8.接下来既然没消息可以处理，那就该处理IdleHandler了。如果pendingIdleHandlerCount小于0（注意其在第一次进入for循环是被初始化为-1）且没更多的消息需要处理，设置pendingIdleHandlerCount=mIdleHandlers.size()；

9.如果pendingIdleHandlerCount还是<=0的话，表示没有idle handler需要执行，

设置mBlocked为true，接着进入下次循环。

10.接下来就是根据mIdleHandlers来初始化mPendingIdleHandlers。退出同步块后我们就剩下最后一件事了，那就是run Idle handlers。一个for循环用来做这就事情，在循环内如果IdleHandler没必要保留，则会从mIdleHandlers中移除。

11. 最后重置pendingIdleHandlerCount为0（也就是4只会在第一次循环的时候执行一次），将nextPollTimeoutMillis设为0，因为当我们在

执行4的时候，新的Message可能已经到来了，所以我们需要立即开始（不需要等待）下次循环来检查。

Message next() {
    //如果消息的 looper 退出，就退出这个方法
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    //也是一个循环，有合适的消息就返回，没有就阻塞
    for (;;) {
        if (nextPollTimeoutMillis != 0) {    //如果有需要过段时间再处理的消息，先调用 Binder 的这个方法
            Binder.flushPendingCommands();
        }

        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            //获取下一个消息
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;    //当前链表的头结点
            if (msg != null && msg.target == null) {
                //如果消息没有 target，那它就是一个屏障，需要一直往后遍历找到第一个异步的消息
                                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                if (now < msg.when) {    //如果这个消息还没到处理时间，就设置个时间过段时间再处理
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 消息是正常的、可以立即处理的
                    mBlocked = false;
                    //取出当前消息，链表头结点后移一位
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();    //标记这个消息在被使用
                    return msg;
                }
            } else {
                // 消息链表里没有消息了
                nextPollTimeoutMillis = -1;
            }

            //如果收到退出的消息，并且所有等待处理的消息都处理完时，调用 Native 方法销毁队列
                        if (mQuitting) {
                dispose();
                return null;
            }

            //有消息等待过段时间执行时，pendingIdleHandlerCount 增加
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                mBlocked = true;
                continue;
            }

            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler

            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }

        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;

        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

Looper

为一个线程运行着一个消息循环，内部有一个消息队列，每一个线程只允许最多存在一个Looper；在Android，这里的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper，这个事android的新概念。我们的主线程（UI线程）就是一个消息循环的线程。针对这种消息循环的机制，我们引入一个新的机制Handle，我们有消息循环，就要往消息循环里面发送相应的消息，自定义消息一般都会有自己对应的处理，消息的发送和清除，消息的的处理，把这些都封装在Handle里面，注意Handle只是针对那些有Looper的线程，不管是UI线程还是子线程，只要你有Looper，我就可以往你的消息队列里面添加东西，并做相应的处理。但是这里还有一点，就是只要是关于UI相关的东西，就不能放在子线程中，因为子线程是不能操作UI的，只能进行数据、系统等其他非UI的操作。使用Looper也非常的简单，它的方法比较少，最主要的有四个:

public static prepare();
public static myLooper();
public static loop();
public void quit();

使用方法如下：

1. 在每个线程的run()方法中的最开始调用Looper.prepare()，这是为线程初始化消息队列。
2. 之后调用Looper.myLooper()获取此Looper对象的引用。这不是必须的，但是如果你需要保存Looper对象的话，一定要在prepare()之后，否则调用在此对象上的方法不一定有效果，如looper.quit()就不会退出。
3. 在run()方法中添加Handler来处理消息
4. 添加Looper.loop()调用，这是让线程的消息队列开始运行，可以接收消息了。
5. 在想要退出消息循环时，调用Looper.quit()注意，这个方法是要在对象上面调用，很明显，用对象的意思就是要退出具体哪个Looper。如果run()中无其他操作，线程也将终止运行。

关于Looper的使用源码中有一个例子：

class LooperThread extends Thread {
      public Handler mHandler;

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

Looper 的属性：

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;  // 主线程中的 Looepr

final MessageQueue mQueue;    //与之管理的消息队列
final Thread mThread;    //所在的线程

private Printer mLogging;
private long mTraceTag;

在线程中创建一个 Looper 以后，就可以调用 Looper.loop() 循环处理消息了，看下它的源码：

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {    //当前线程必须创建 Looper 才可以执行
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;

    //底层对 IPC 标识的处理，不用关心 
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) {    //无限循环模式
        Message msg = queue.next(); //从消息队列中读取消息，可能会阻塞
        if (msg == null) {    //当消息队列中没有消息时就会返回，不过这只发生在 queue 退出的时候
            return;
        }

        //...
        try {
            msg.target.dispatchMessage(msg);    //调用消息关联的 Handler 处理消息
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        //...
        msg.recycleUnchecked();    //标记这个消息被回收
    }
}

可以看到，Looper.loop() 也很简单，就是调用 MessageQueue.next() 方法取消息，如果没有消息的话会阻塞，直到有新的消息进入或者消息队列退出。
拿到消息后调用消息关联的 Handler 处理消息。

loop() 源码中的注释就提醒我们，开启循环调度消息后不要忘记调用 quit() 方法结束循环。
Looper.quit() 和 quitSafely () 源码:
public void quit() {
mQueue.quit(false);
}

public void quitSafely() {
mQueue.quit(true);
}
两种退出方式都调用的是 MessageQueue.quit(boolean) 方法。
Looper 两种结束方式的区别：

quit()：立即把消息链表中的所有消息都回收了，比较强硬
    在停止后如果 Handler 还发送消息，会返回 false，表示入队失败
    这个方法是不安全的，一般建议使用下面那个
quitSafely()：比上面那个温柔一点
    只会将还未执行的消息回收掉
    在调用之后添加进入的消息不会被处理，Handler.sendMessage 也会返回 false

当消息队列被标记位退出状态时，它的 next() 方法会返回 null，于是 Looper.loop() 循环就结束了。