Handler深入解析(一)

网上看了一堆各种Handler解析、详解的,但是感觉流程没有说透。我结合自己的理解和源码来综合性说说吧!

Handler源码定义的两大作用:

1. 线程间通信

2. 定时任务

 

一、Handler的初始化

我从定义构造方法开始讲起吧!

Handler的构造方法主要有两种,然后通过这两种形成各种使用灵活的构造方法!

 

第一种:

publicHandler(Callback callback,booleanasync) {//hide方法,默认无法构造
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) ==0) {
            Log.w(TAG,"The following Handler class should be static or leaks might occur: "+
                klass.getCanonicalName());
        }
    }

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

相关的构造方法有:

publicHandler() {
    this(null,false);
}

publicHandler(Callback callback) {
    this(callback, false);
}

publicHandler(booleanasync) {//hide方法,默认无法构造
    this(null, async);
}

第二种:

publicHandler(Looper looper, Callback callback,booleanasync) {//hide方法
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

对应的各种构造方法是:

publicHandler(Looper looper) {
    this(looper, null, false);
}

publicHandler(Looper looper, Callback callback) {
    this(looper, callback,false);
}

 

两种方法的核心区别就是Looper的初始化,但是两种构造方法默认外部是无法调用的,Handler类隐藏了所有关于mAsynchronous的初始化设置!

 

先来说说第一种Handler的构建:

一来就是if判断,还是一个私有静态常量,一看就是用不上的,那么作用呢?

private static final booleanFIND_POTENTIAL_LEAKS=false;

官方解释是:将此标志设置为true以检测扩展的Handler类,如果不是静态的匿名,本地或成员类, 这类可能会产生泄漏。

也就是我们常见构造时的警告说明!至于消除警告方法一般是设置成静态或弱引用。继续看下面的代码

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

首先是默认Looper的构造初始化,关于这些变量,我们先看看声明:

finalMessageQueuemQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;

全都用final修饰,也就是说每一个Handler只能绑定一个Looper、一个MessageQueue、一个Callback。至于我们用来发送和接收的Message则没有任何限制!至于mAsynchronous一般构造方法获取到的,都是默认的false,主要是针对Message的排队处理!这里还有一点就是除了Callback外,其他变量都不能为空,否则消息处理时会抛异常,因为Callback接口内部方法未实现时会调用本地的handlerMessage方法,两者不同在于Callback的回调方法有boolean类型的返回值!

第二种构建方法就简单了,直接把需要初始化的局部变量赋值就行了,这里没什么可说的。

 

二、消息发送

Handler的消息发送主要有两种,一种是post,另一种是send

先来看post处理方法。post主要是自己开启一个Runnable线程处理事件,并能指定事件的处理时间(延时多少时间处理)。重载方法如下:

public final booleanpost(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r),0);
}

public final booleanpostAtTime(Runnable r,longuptimeMillis)
{
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}

public final booleanpostAtTime(Runnable r, Object token,longuptimeMillis)
{
    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}

public final booleanpostAtTime(Runnable r, Object token,longuptimeMillis)
{
    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}

public final booleanpostDelayed(Runnable r,longdelayMillis)
{
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

public final booleanpostAtFrontOfQueue(Runnable r)//特殊方法
{
    return sendMessageAtFrontOfQueue(getPostMessage(r));
}

从上面可以看出,post方法最终调用的还是send方法将消息添加到消息队列,而且还都是final方法,不可重写,也提高了执行效率。现在来讲解第一个方法,其他类似。post方法默认调用了sendMessageDelayed(getPostMessage(r), 0); 。先来看看线程处理方法getPostMessage(r)

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

私有的静态方法,是为了将处理事件添加到Message消息线程中,并返回了Message

在看sendMessageDelayed方法

public final booleansendMessageDelayed(Message msg,longdelayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

直接就是调用send方法了。也就是说post方法最后还是要调用send方法来将消息添加到消息队列中,下面我们来看直接来看send方法。

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

public final booleansendEmptyMessage(intwhat)
{
    return sendEmptyMessageDelayed(what,0);
}

public final booleansendEmptyMessageDelayed(intwhat,longdelayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}

public final booleansendEmptyMessageAtTime(intwhat,longuptimeMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageAtTime(msg, uptimeMillis);
}

public final booleansendMessageDelayed(Message msg,longdelayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public booleansendMessageAtTime(Message msg,longuptimeMillis) {//
    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);
}

public final booleansendMessageAtFrontOfQueue(Message msg) {//特殊方法
    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,0);
}

还是从最简单的sendMessage方法说起,直接调用sendMessageDelayed方法,继续看,延时做了合法性判断后调用了sendMessageAtTime方法,也就是指定任务的执行发生时间。继续看里面的代码,先是获取的此Handler的消息队列MessageQueue,并做了null判断,这里先不探讨出现null的情况,继续往下看,然后调用了enqueueMessage方法:

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

这个私有方法就将消息添加到了消息队列中,消息发送也就完成了。

postsend方法中,有一种比较特殊的消息发送机制,就是消息插队(备注的特殊方法),也就是postAtFrontOfQueue和sendMessageAtFrontOfQueue方法,因为postAtFrontOfQueue是通过sendMessageAtFrontOfQueue方法实现的,但最终还是一样的,只不过这种方法会出排序问题或其他情况等,一般很少使用!

从上面可以看出,无论是post还是send方方法,都是将Message添加到MessageQueue中,Handler还提供了获取Message的几种构造方法:

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

public finalMessage obtainMessage(intwhat)
{
    return Message.obtain(this, what);
}

public finalMessage obtainMessage(intwhat, Object obj)
{
    return Message.obtain(this, what, obj);
}

public finalMessage obtainMessage(intwhat,intarg1,intarg2)
{
    return Message.obtain(this, what, arg1, arg2);
}

public finalMessage obtainMessage(intwhat,intarg1,intarg2, Object obj)
{
    return Message.obtain(this, what, arg1, arg2, obj);
}

基本都是Message的构造方法,但全部没有用new方法,而是通过obtain方法获取,而这也是Message类推荐的。

到这里Handler的消息发送和发送相关的方法就基本讲完了!Handler的主要方法之一也就讲的差不多了!下一节继续Handler的消息移除和消息处理

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值