说说你对Handler的理解?

Android的消息机制是Android系统中很重要的一块,在Android系统中运用的非常多,比如Activity的启动以及Activity的生命周期都是通过消息机制完成的。

流程

首先看一下消息机制的大致流程:


Handler流程.png

从上图中,我们可以看到消息机制主要分为四大块:Handler,Message,MessageQueue,Looper,下面我们分为对这4大块进行讲解。

Message

message是一个消息对象,它相当于链表的节点,里面存储了消息数据和下一个消息对象信息:

    public int what;
    public int arg1;
    public int arg2;
    public Object obj;
    public Messenger replyTo;
    public int sendingUid = -1;
    /*package*/ static final int FLAG_IN_USE = 1 << 0;
    /** If set message is asynchronous */
    /*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;
    /** Flags to clear in the copyFrom method */
    /*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
    /*package*/ int flags;
    /*package*/ long when;
    /*package*/ Bundle data;
    /*package*/ Handler target;
    /*package*/ Runnable callback;
    // sometimes we store linked lists of these things
    /*package*/ Message next;

从图中我们可以看到,好多字段都是我们以前用过的。

Handler

handler是负责发送和处理消息的,发送的流程如下:

        Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
            }
        };
        
        Message message = new Message();
        message.what = 0;
        handler.sendMessage(message);
    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) {
            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);
    }

这里是将消息进行部分处理,然后通过MessageQueue的enqueueMessage将消息加入到但链表中。

至于消息的处理,它是通过Looper循环器从MessageQueue中取出消息,然后发送到Handler中的dispatchMessage方法,这个稍后会在Looper中分析到,我们先看看dispatchMessage方法:

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

可以看到最终调用了handleMessage方法,就是我们new Handler对象会重载的方法,在里面处理一系列数据。

Looper

looper:循环调度器,是负责不断的从MessageQueue中取出Message,一个线程只能有一个Looper:

    public static void prepare() {
        prepare(true);
    }
    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));
    }
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

接下来,让我看看循环调度器是怎么取出消息的?

public static void loop() {
        final Looper me = myLooper();
        final MessageQueue queue = me.mQueue;
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            try {
                msg.target.dispatchMessage(msg);
            } finally {
            }
        }
    }

从上面我们可以看到他开启了一个无限循环,不断的从Message Queue中取消息,当消息不为空的时候,他会回调Handler的dispatchMessage的方法,就是我们上面Handler所说的。

MessageQueue

messageQueue:消息队列,负责消息的插入和取出。

boolean enqueueMessage(Message msg, long when) {
        synchronized (this) {
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            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 {
                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;
            }
        }
        return true;
    }

Message next() {
        for (;;) {
            nativePollOnce(ptr, nextPollTimeoutMillis);
            synchronized (this) {
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != 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;
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    nextPollTimeoutMillis = -1;
                }
                if (mQuitting) {
                    dispose();
                    return null;
                }
        }
    }

这就是对单链表的操作,是按照when排序的。这里要注意的是nativePollOnce(ptr, nextPollTimeoutMillis)这个方法,这是调用了native层的方法,利用epoll机制在之前建立的管道上等待数据写入,接收到数据后马上读取并返回结果,简单的来说当没有消息时,会阻塞在这里,释放cpu资源,进入休眠状态,等待通知,当有消息的时候,会继续往下读取消息,如果读到消息,将返回给looper循环调度器

Handler引起的内存泄漏问题

我们都知道非静态内部类会持有外部类的引用,在activity的声明Handler的内部类,也会持有activity对象的引用,当activity退出而Handler正在处理任务时就会造成activity的泄漏问题,此时gc扫描时,该activity的对象还在被使用,所以不能回收掉。解决方法:将非静态类修改为静态内部类,在其内部使用弱引用。

private static class UpdateHandler extends WeakHandler<TopSiteView> {
        public UpdateHandler(TopSiteView ref) {
            super(ref);
        }
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            TopSiteView topSiteContext = getRef().get();
            if (topSiteContext != null) {
                topSiteContext.initView();
            }
        }
    }

public class WeakHandler<T> extends Handler {
    protected WeakReference<T> mReference;
    public WeakHandler(T ref) {
        mReference = new WeakReference<T>(ref);
    }
    public WeakHandler(Looper looper, T ref) {
        super(looper);
        mReference = new WeakReference<>(ref);
    }
    protected WeakReference<T> getRef() {
        return mReference;
    }
}

FAQ

一个线程中能有几个Handler?如何保证唯一?

1.一个线程中可以创建多个Handler,就像我们可以在每个activity中创建一个Handler,但是Looper只能有一个,这个在我们上面分析Looper的时候也说了,就相当于一个Looper对应一个MessageQueue,一个MessageQueue对应多个Message,而Message中的target持有Handler对象,同理一个线程可以创建多个Handler.
2.ThreadLocal保证唯一,原因稍后研究。

主线程的Looper和子线程的Looper有什么区别?

通过上面的源码分析,他们的创建过程prepare()和prepareMainLooper()可以看到他们只有quitAllowed参数是不一样的,那我们可以往下追踪一下

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }
MessageQueue(boolean quitAllowed) {
        mQuitAllowed = quitAllowed;
        mPtr = nativeInit();
    }
void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }

从源码中可以知道mQuitAllowed只在quit方法中使用到了,从这里我们就可以知道一个区别:主线程的Looper是不可以退出的,而子线程Looper是可以退出的,这个方法往下的操作就是删除消息队列里的内容。

如果有不对的或者缺漏的地方帮忙指出,共同进步,谢谢!

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

推荐阅读更多精彩内容