前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Android源码解读-Handler、Looper、MessageQueue

Android源码解读-Handler、Looper、MessageQueue

原创
作者头像
笔头
修改2023-03-29 16:39:26
1.2K0
修改2023-03-29 16:39:26
举报
文章被收录于专栏:Android记忆

一、是什么

在启动一个线程时,会创建一个Looper,同时在内部创建一个消息队列MessageQueue,此时线程会进入一个无限循环中,不断检查消息队列是否有消息。如果有就从消息队列里面取出来,通过Handler来处理消息,否则,线程进入睡眠状态,直到有新消息为止。(队列里消息是通过Handler发送的)

接下来我们就逐步学习他吧。

二、源码解析

Looper源码解析

Android应用程序进程在启动的时候,会在线程中加载 /frameworks/base/core/java/android/app/ActivityThread.java类,并且执行这个类的main函数,应用程序的消息循环过程就是在这个main函数里面实现的。

代码语言:javascript
复制
public static void main(String[] args) {
    ......
    Looper.prepareMainLooper();
    ......
    Looper.loop();
    ......
}

这个就是系统UI线程的一个Looper

1.创建Looper

prepareMainLooper方法只能调用一次

代码语言:javascript
复制
public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

prepare方法:

代码语言:javascript
复制
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));
}

1.这个会判断当前线程ThreadLocal是否已经存在Looper,如果不存在,则创建一个新Looper存放在ThreadLocal中,后面myLooper()方法会从当前线程中的ThreadLocal获取Looper。

2.我们可以看出,一个线程只能有一个Looper,多次调用prepareMainLooper会报错

我们来看看Looper创建实例

代码语言:javascript
复制
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

做了2件事,1.创建MessageQueue,也就是存放Message的队列。2.获得当前线程,这个线程主要用来判断Looper是不是属于当前线程。

myLooper方法,比较简单,直接从ThreadLocal取出。ThreadLocal可以参考这篇文章 ThreadLocal浅析

代码语言:javascript
复制
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

上面我们知道Looper的来源,创建Looper的时候同时创建了MessageQueue。接下来看下,Looper是如何无限循环遍历消息队列的。

loop源码

代码语言:javascript
复制
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;
    ......
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            return;
        }
        ......
        try {
            msg.target.dispatchMessage(msg);
        ......
        } 
        ......
    }
}

我们可以看到loop里面是通过for(;;)无限循环,通过queue.next()不断重消息队列MessageQueue获取消息,这MessageQueue是个阻塞式的队列。在没有消息时,当前线程在next中进入睡眠状态,否则通过msg.target.dispatchMessage(msg)把消息进行处理,这里的msg.target就是Handler,后面将会提到。

我们来看下next是如何运行的吧。

next源码

代码语言:javascript
复制
Message next() {
    final long ptr = mPtr;
    ...............
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            
            //-------------------1----------------------------
            if (msg != null && msg.target == null) {
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
            
                //-----------------------------2--------------------
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    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 {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            .............
    }
}

上面源码中,nextPollTimeoutMillis是一个重点,表示睡眠时间。

nativePollOnce(ptr, nextPollTimeoutMillis);【内部源码这里就先暂时不看了,有机会以后再看看】

当nextPollTimeoutMillis=-1时,表示没有消息,当前线程会进入无限睡眠状态。

当nextPollTimeoutMillis=0时,表示当前线程不会进入睡眠状态。

当nextPollTimeoutMillis>0时,当前线程会睡眠nextPollTimeoutMillis时间。

在代码1中,我们可以得知,如果头Message的target为null,则查找一个异步Message来进行下一步处理。

如果没有拿到数据,即msg==null,那nextPollTimeoutMillis=-1,那下次调用nativePollOnce时,当前线程会进入无限睡眠状态。

在代码2中,如果拿到数据了,接下来就是考虑延迟处理消息还是直接处理消息。

1.判断下他的when【系统开机截止到现在的时间+delay时间】和系统开机截止到现在的时间now比较,如果when大于now,那当前线程就会睡眠nextPollTimeoutMillis,也就阻塞nextPollTimeoutMillis

2.正常情况下prevMsg==null,我们直接拿当前正在处理的msg的next作为新的待处理mMessages,同时清除当前正在处理msg的next。

Looper大致就这些,下面看下Handler

Handler源码解析

无限循环遍历MessageQueue过程就这些,上面讲了如何获取Message以及MessageQueue如何阻塞的。接下来是对遍历MessageQueue下来的Message进行处理。也就是执行msg.target.dispatchMessage(msg);

在看msg.target.dispatchMessage(msg);之前,我们先看下,Handler如何发送消息的吧。

enqueueMessage源码

Handler 发送消息最终是调用Handler.enqueueMessage

代码语言:javascript
复制
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

嘿嘿,这里我们发现msg.target =this;target就是当前Handler这个queue是哪里来的?看下Handler的构造函数我们可以知道,此时的queue即MessageQueue是从当前线程Looper中取得的。这里就不贴代码了。

接下来看MessageQueue的enqueueMessage源码

代码语言:javascript
复制
boolean enqueueMessage(Message msg, long when) {
    ..............
    synchronized (this) {
    ...............
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        //----------------------1-------------------
        if (p == null || when == 0 || when < p.when) {
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
        //--------------------2---------------------
            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;
        }
       //-------------------------3-------------------
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

看代码1,假如when==0或when小于当前正在处理msg的when或者队列为空,就把新添加的msg放到对头。这很好理解,when越小的越靠近对头,MessageQueue 是一个按照处理时间从小到大排序的队列,loop遍历MessageQueue是从对头开始获取数据。

代码2,这个情况是新添加的msg的when比当前正在处理的msg的when要大,那就遍历队列,直到找到when比新添加的msg的when大的msg,然后插入。

代码3,每次插入msg的时候,判断needWake,是否要唤醒当前线程,上面代码我们知道,当消息插入对头的时候,如果当前线程处于睡眠状态,needWake=true。当消息插入中间时,needWake=false。

MessageQueue的enqueueMessage相对容易理解,上面是添加Message的整个过程,接下来我们是时候看看Handler是如何处理消息的。

dispatchMessage源码

代码语言:javascript
复制
public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

这里面主要有两个变量需要重点看看

1.msg.callback,这个是在什么时候定义的呢?

我们先看下handleCallback(msg)

代码语言:javascript
复制
private static void handleCallback(Message message) {
    message.callback.run();
}

这个callback执行了run方法,好像是个Runnable,我们搜索Handler源码看下,我们在调用post方法时会提供Runnable参数,

代码语言:javascript
复制
handler.post(new Runnable() {
    @Override
    public void run() {
    }
})

那我们知道,此时的callback就是个Runnable。

2.mCallback,这个变量什么时候定义的?看下Handler的构造函数,我们知道,这里的mCallback就是Handler里定义的Callback接口。

代码语言:javascript
复制
public interface Callback {
    boolean handleMessage(@NonNull Message msg);
}

就是如果你定义了Callback接口,那数据处理就在handleMessage里处理。

代码语言:javascript
复制
Handler handler=new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(@androidx.annotation.NonNull Message msg) {
        return false;
    }
});

这个时候,我们再回看第一节对Handler、Looper、MessageQueue的描述,是不是有更深刻的理解了。

三、相关设计模式

1.享元模式:

消息系统需要不断的产生Message、处理Message、销毁Message,这种重复大量的构建Message,recycleUnchecked方法并不是销毁Message,而是把Message里的各种成员变量置为null,下次有新的消息的时候,直接复用,而不是再去new Message,减少了内存碎片的出现,减少了内存抖动,提高了程序的性能。

2.生产消费设计模式:

生产者enqueueMessage往queue中入队消息,next往MessageQueue里拿消息是一个消费者。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 一、是什么
  • 二、源码解析
    • Looper源码解析
      • loop源码
        • next源码
          • Handler源码解析
            • enqueueMessage源码
              • dispatchMessage源码
              • 三、相关设计模式
                • 1.享元模式:
                  • 2.生产消费设计模式:
                  相关产品与服务
                  消息队列 CMQ 版
                  消息队列 CMQ 版(TDMQ for CMQ,简称 TDMQ CMQ 版)是一款分布式高可用的消息队列服务,它能够提供可靠的,基于消息的异步通信机制,能够将分布式部署的不同应用(或同一应用的不同组件)中的信息传递,存储在可靠有效的 CMQ 队列中,防止消息丢失。TDMQ CMQ 版支持多进程同时读写,收发互不干扰,无需各应用或组件始终处于运行状态。
                  领券
                  问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档