Handler机制-源码分析

[toc]

问题1:Handler机制是怎么实现线程间通信的?

问题2:post(runnable)方法发送的runnable为什么能在主线程执行?

创建

首先,看一下创建Handler的过程:

//Handler.java

final Looper mLooper;
final MessageQueue mQueue;

public Handler() {
    this(null, false);
}

public Handler(@Nullable Callback callback, boolean async) {
    ...
    mLooper = Looper.myLooper();    //获取当前线程的looper实例
    ...
    mQueue = mLooper.mQueue;    //当前线程的消息队列
    mCallback = callback;       //用于处理消息
    mAsynchronous = async;
}

在Handler的构建方法中,主要是字段赋值,通过Looper.myLooper()获取了Looper实例,接下来就看一下Looper.myLooper()的源码。

//Looper.java

//ThreadLocal用于线程局部变量,值与调用线程关联
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

/**
 * 返回与当前线程关联的Looper对象。如果调用线程没有与循环器关联,则返回null。
 */
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

public static void prepare() {
    prepare(true);
}

private static void prepare(boolean quitAllowed) {
    ...
    sThreadLocal.set(new Looper(quitAllowed));
}

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

:ThreadLocal类型用于线程局部变量,它的值将保存在thread.threadLocals字段,get/set时通过Thread.currentThread()方法获取当前线程thread实例来访问。

Looper.myLooper()返回的looper来自静态字段sThreadLocal,而sThreadLocal的值是在Looper.prepare()方法中创建的looper实例。(Looper.prepare()并不是在创建handler时调用,而是在之前调用)

  • 主线程已在ActivityThread.main()方法中调用了Looper.prepareMainLooper()Looper.loop(),无需我们负责;
  • 在其他线程创建Handler时,必须在new Handler()前,调用Looper.prepare(),否则会引发RuntimeException

分析到这里,可以知道handler.mLooper引用的looper是和线程关联的,是线程局部变量,在Looper中创建的消息队列自然也和线程关联。所以Handler在创建时便和线程绑定了,由handler发送的消息,才能在创建handler的线程处理。

发送消息

handler最常见的用法是sendMessage(msg)post(runnable),先看handler.sendMessage()方法的源码:

//Handler.java

public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    //SystemClock.uptimeMillis()返回开机后的毫秒数
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

//参数uptimeMillis指定处理消息的时间
public boolean sendMessageAtTime(@NonNull 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(@NonNull MessageQueue queue, @NonNull Message msg,
                               long uptimeMillis) {
    msg.target = this;      //消息发送的目标,表示消息将投递到当前handler处理
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);     //将消息放入队列
}

经过几层调用,添加了预定处理时间,设置了发送目标后,消息被放入handler.mQueue,之前已经分析过这个消息队列和创建handler的线程绑定。

另外在handler.enqueueMessage()中设置了msg.target = this,这说明发送消息和处理消息一定是同一个handler。

然后看一下queue.enqueueMessage()方法。

//MessageQueue.java

private long mPtr;  // 大概相当于native层的线程id
Message mMessages;  //链表:保存等待处理的消息
private boolean mBlocked;   //指示消息队列关联的线程是否阻塞
private boolean mQuitting;  //消息队列是否已废弃

boolean enqueueMessage(Message msg, long when) {
    ...
    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();      //回收message对象,保存至Message.sPool
            return false;
        }

        msg.markInUse();
        msg.when = when;    //消息预设的投递时间
        Message p = mMessages;
        boolean needWake;   //是否需要唤醒线程
        //根据when决定消息插入队列的位置
        if (p == null || when == 0 || when < p.when) {
            // 新的头,如果阻塞,唤醒事件队列。
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            // 插入到队列中间。通常我们不需要唤醒事件队列,
            // 除非队列前面有一个屏障,并且消息是队列中最早的异步消息。
            // p.target == null代表一个‘同步屏障’消息,它之后的同步消息暂时不投递
            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.enqueueMessage()的主要工作是根据参数when将消息插入队列适当位置,判断线程是否阻塞,是否需要唤醒线程。

总结一下:

  • handler.sendMessage(msg)的过程,就是将msg放入handler.mQueue.mMessags
  • 消息将被 发送它的handler 处理

下面看一下handler.post()方法的源码:

//Handler.java

public final boolean post(@NonNull Runnable r) {
    return  sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postDelayed(@NonNull Runnable r, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

public final boolean postAtTime(@NonNull Runnable r, long uptimeMillis) {
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}

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

很明显,post()方法只是生成一个message对象,然后通过sendMessage...()方法发送。不同的是这里设置了message.callback字段,另外使用过handler.post()一定知道,这些消息不会通过handler.handleMessage()处理,那么post()产生的消息会怎么处理呢?我们在“分发消息”部分分析。

分发消息

消息队列中的消息是在Looper.loop()方法中分发的,直接看源码。

//Looper.java

/**
 * 在此线程中运行消息队列。一定要调用quit()来结束循环。
 */
public static void loop() {
    final Looper me = myLooper();
    ...
    final MessageQueue queue = me.mQueue;
    ...
    for (;;) {
        Message msg = queue.next(); //从消息队列取出消息。(可能阻塞)
        //正常时候,队列中没有消息,会阻塞线程,不会返回null
        if (msg == null) {
            // 没有消息 表示消息队列正在退出。
            return;
        }
        ...
        // 确保观察者在处理事务时不会改变。
        final Observer observer = sObserver;
        ...
        Object token = null;
        if (observer != null) {
            token = observer.messageDispatchStarting();
        }
        ...
        try {
            //将消息投递到handler。(msg.target为发送消息的handler)
            msg.target.dispatchMessage(msg);
            if (observer != null) {
                observer.messageDispatched(token, msg);
            }
        } catch (Exception exception) {
            if (observer != null) {
                observer.dispatchingThrewException(token, msg, exception);
            }
            throw exception;
        } finally {
            ...
        }
        ...
        msg.recycleUnchecked();     //回收msg实例
    }
}

主要逻辑很简单,就是从消息队列取出消息,投递给指定的handler,然后回收消息。所以在这里只是把消息分发到了handler,然后再看handler.dispatchMessage(msg)怎么分发消息:

//Handler.java

@UnsupportedAppUsage
final Callback mCallback;   //创建handler时设置,用于处理消息

public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        //post(runnable)产生的消息,在此处理
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

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

/**
 * 子类必须实现此方法以接收消息。
 */
public void handleMessage(@NonNull Message msg) {
}

/**
 * 创建Handler实例时使用,避免实现Handler子类
 */
public interface Callback {
    boolean handleMessage(@NonNull Message msg);
}

handler.dispatchMessage(msg)的逻辑很简单,按照以下优先级分发消息 msg.callback > mCallback > handleMessage()

  • handleCallback()直接运行message.callback
  • handleMessage()需要在子类中实现
  • handler.mCallback只有一个方法,功能与handler.handleMessage()相同,只是省得写Handler子类。(感觉没什么用)

Looper.loop()中调用了MessageQueue.next(),这里也看一下:

//MessageQueue.java

private long mPtr;  // 大概相当于native层的线程id
Message mMessages;  //链表:保存等待处理的消息
private boolean mBlocked;   //指示消息队列关联的线程是否阻塞
private boolean mQuitting;  //消息队列是否已废弃

@UnsupportedAppUsage
Message next() {
    ...
    int nextPollTimeoutMillis = 0;  //预设阻塞时长
    for (;;) {  //注意:没找到可返回的消息时,会循环
        ...
        //使线程阻塞,nextPollTimeoutMillis为预设阻塞最长时间,可以提前唤醒
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            // 尝试检索下一条消息。如果找到则返回。
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                //msg.target==null代表一个‘同步屏障’消息,它之后的同步消息暂时不投递
                // 队列头是同步屏障,则查找下一个异步消息。
                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 {
                    // 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 {
                // 没有消息,使线程一直阻塞。enqueueMessage()中有唤醒逻辑
                nextPollTimeoutMillis = -1;
            }

            // 现在处理退出消息,所有挂起的消息都已处理。
            if (mQuitting) {
                dispose();  
                return null;
            }
            ...
        }
        ...
    }
}

总结

  • 在主线程创建handler实例后,可以在不同线程使用这个handler实例发送消息,这些消息都会放到主线程的消息队列中,而主线程在Looper.loop()方法中不断地取出消息处理消息。
  • 主线程调用Looper.loop()后会无限循环,那么Activity生命周期方法、屏幕刷新、点击事件等只能在处理消息时执行。
  • 在我们自定义的线程也可以使用Looper,使线程长久运行。

参考

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 219,635评论 6 508
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 93,628评论 3 396
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 165,971评论 0 356
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 58,986评论 1 295
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 68,006评论 6 394
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 51,784评论 1 307
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 40,475评论 3 420
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 39,364评论 0 276
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 45,860评论 1 317
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 38,008评论 3 338
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,152评论 1 351
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 35,829评论 5 346
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 41,490评论 3 331
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 32,035评论 0 22
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,156评论 1 272
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 48,428评论 3 373
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 45,127评论 2 356

推荐阅读更多精彩内容