宵待草夜情

春宵苦短,少年前进吧!

深入理解Handler、Message、MessageQueue、Looper

本文是从源码的角度对andorid异步消息处理机制的梳理,那么在文章开始阶段,先简单介绍,异步消息处理机制中各部件的作用以及处理处理机制的概述

1、Handler、Message、MessageQueue、Looper功能简述

Handler负责消息处理,包括消息的发送和消息的接收,内部跟Looper有关联。

Message是消息的载体,里面封装了消息的具体内容

MessageQueue是消息列表,存在着由Handler发送的Message,注意,MessageQueue内部是链表实现,并不是队列

Looper会创建一个死循环,负责从MessageQueue中循环取出Message

2、异步消息处理机制简述

android通过Handler发送异步消息Message放入MessageQueue消息列表中,在Handler内部有一个Looper,Looper的实现是一个死循环,负责从MessageQueue中取出Message,并将Message传递回给Handler,最后Handler负责处理对应message。

3、andorid为什么要使用异步消息处理机制

主要用于处理多线程更新ui的并发问题。若没有异步消息处理机制,此时多个线程在不加同步锁的情况下去更新ui界面,那很可能会造成ui页面的显示的错乱。

接下来从源码的角度剖析Handler、Message、MessageQueue、Looper的具体实现

Handler

Handler构造方法如下

public Handler(Callback callback, boolean async) {
        ......
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        } 
        mQueue = mLooper.mQueue;      
         ......   
    }

实例化Handler同时,通过调用Looper的myLooper()方法一并初始化了Looper对象,当Looper对象为空时会抛出一个异常,那么myLooper()方法获取的对象何时为空?

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); 

public static Looper myLooper() {
        return sThreadLocal.get();
}

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对象是从sThreadLocal变量中获取,而sThreadLocal又是在Looper调用prepare()方法后设置的,同时在设置之前,会判断是否已存在Looper对象,若存在,直接抛出异常,这表明,一个Handler只能包含一个Looper

一般实例化一个Handler对象后,Handler便承担了发送消息的任务,Handler有以下方法用于发送消息

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

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {  
    Message msg = Message.obtain();  
    msg.what = what;  
    return sendMessageDelayed(msg, delayMillis);  
}  

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

其实最终调用到的就一个方法,sendMessageAtTime()方法,而sendMessageAtTime()方法就是直接调用了enqueueMessage()方法

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
     msg.target = this;  
     if (mAsynchronous) {  
         msg.setAsynchronous(true);  
     }  
     return queue.enqueueMessage(msg, uptimeMillis);  
 }

这里的this指的是当前Handler对象,queue调用enqueueMessage()方法,将Handler发送出去的Message对象放入queue中

此时已经将消息存入MessageQueue中了,那么下一步就是Looper去取MessageQueue中的Message,并传递给Handler

Looper

前面已经介绍,Looper的初始化是在Handler的构造方法中进行的,在做完这些准备工作后,Looper就会开启循环去获取MessageQueue中的Message,执行的方法是loop()方法

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;  
  
        // Make sure the identity of this thread is that of the local process,  
        // and keep track of what that identity token actually is.  
        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;  
            }  
  
            // This must be in a local variable, in case a UI event sets the logger  
            Printer logging = me.mLogging;  
            if (logging != null) {  
                logging.println(">>>>> Dispatching to " + msg.target + " " +  
                        msg.callback + ": " + msg.what);  
            }  
  
            msg.target.dispatchMessage(msg);  
  
            if (logging != null) {  
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
            }  
  
            // Make sure that during the course of dispatching the  
            // identity of the thread wasn't corrupted.  
            final long newIdent = Binder.clearCallingIdentity();  
            if (ident != newIdent) {  
                Log.wtf(TAG, "Thread identity changed from 0x"  
                        + Long.toHexString(ident) + " to 0x"  
                        + Long.toHexString(newIdent) + " while dispatching to "  
                        + msg.target.getClass().getName() + " "  
                        + msg.callback + " what=" + msg.what);  
            }  
  
            msg.recycle();  
        }  
}  

可以看到,在第13行代码,程序进入一个死循环,然后获取到一个非空的Message对象后,Handler会调用dispatchMessage()方法

public void dispatchMessage(Message msg) {
    //第一种处理消息方式
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            //第二种处理消息方式
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //第三种处理消息方式
        handleMessage(msg);
    }
}

根据源码可以看出,Handler一共有三种处理消息的方式,那让我们来分析一下,都是哪些情况会执行对应的处理方式

其实handler发送消息的方式分两大系列,第一类是send系列,第二类是post系列。

send系列

Message msg = mHandler.obtainMessage();
//发送一个消息码为0的空消息
mHandler.sendEmptyMessage(0);
//发送一个消息码为0,绝对时间点为1000ms的空消息,该时间应该大于等于当前时间,下同
mHandler.sendEmptyMessageAtTime(0, 1000);
//发送一个消息码为0,延时时间为1000ms的空消息
mHandler.sendEmptyMessageDelayed(0, 1000);
//发送一个没有延时的msg封装的消息
mHandler.sendMessage(msg);
//发送一个绝对时间点为1000ms的msg封装的消息
mHandler.sendMessageAtTime(msg, 1000);
//发送一个延时时间为1000ms的msg封装的消息
mHandler.sendMessageDelayed(msg, 1000);
//立即发送一个msg封装的消息到消息队列的最前端
mHandler.sendMessageAtFrontOfQueue(msg);

分析源码可知,除了最后一中调用,其余所有send系列的方法,最终都是调用sendMessageAtTime()方法。

而此时,Handler对应的dispatchMessage()方法,所执行到的是第二种处理消息方式和第三种处理消息方式,主要看实现的Handler类的构造方法中有没有传入CallBack对象

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        //接收消息之后,处理消息
    }
};

以上的形式,Handler对应的dispatchMessage()会调用第三种处理消息方式

private Handler handler1 = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        //接收消息之后,处理消息
        return true;
    }
});

以上的形式,Handler对应的dispatchMessage()会调用第二种处理消息方式,值得注意的是,CallBack接口对象的handleMessage()方法带有一个boolean的返回值,若返回false,此方法执行完后,消息会继续传递到第三种处理消息方法中去,所以如果没有特殊的要求,此方法一般返回true。

post系列

mHandler = new Handler();

mHandler.post(new Runnable() {
    @Override
    public void run() {
            
        }
    });

mHandler.postAtTime(new Runnable() {
    @Override
    public void run() {
              
    }
}, new Object(), 1000);

mHandler.postDelayed(new Runnable() {
    @Override
    public void run() {
           
    }
}, 1000);

mHandler.postAtFrontOfQueue(new Runnable() {
    @Override
    public void run() {
              
    }
});

此处Handler不是发送Message对象,而是发送一个Runnable接口,那么Handler不是发送Message对象的吗?这里怎么发生Runnable接口?其实最终发送的还是Message对象,只是在后续的进行了转换

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

post系列方法最终都会调用到PostAtTime()方法,内部依旧是调用了sendMessageAtTime()方法,只是通过调用getPostMessage方法,对Runnable接口进行了转换。

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

Message对象的callback变量,赋值为传入的Runnable接口,那么由此可以看出,以post系列的所有方法所传入的消息,最终都会执行Handler中dispatchMessage()方法中的第一种处理消息方式。

Message

Message对象的创建,一般采用Message的obtain()方法或者obtainMessage()方法,而不是以Message message = new Message()形式进行,这是官方文档所建议的。主要原因是因为,Message内部维护了一个消息池,执行obtain()方法或者obtainMessage()方法便是从消息池中获取实例,从而避免实例化带来的内存浪费。

/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

Handler使用不当造成内存泄漏

内存泄漏的定义是对象持有比自己生命周期长的对象引用,导致自身无法被垃圾回收器回收。

那么在handler的使用过程中,什么时候会造成内存泄漏?举个例子,当你开启Thread请求异步数据,发出请求后,你退出当前activity,而异步数据在你退出activity页面后才返回,此时,activity对象将永远持有handler对象,导致无法被回收,造成内存泄漏。解决方法:

//从消息队列中移出post系列方法中Runnable对象的消息
mHandler.removeCallbacks(Runnable r);
//从消息队列中移除消息码为“what”的消息
mHandler.removeMessages(int what);

可以在activity的onDestory()中调用以上方法,移除未执行完毕的异步请求,清除消息队列中对应的消息。




阅读更多
版权声明: https://blog.csdn.net/weixin_41975165/article/details/79963935
个人分类: android
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

深入理解Handler、Message、MessageQueue、Looper

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭