澳门新葡萄京官网注册 15

澳门新葡萄京官网注册Handle的原理(Looper、Handler、Message三者关系)

handler在安卓开发中是必须掌握的技术,但是很多人都是停留在使用阶段。使用起来很简单,就两个步骤,在主线程重写handler的handleMessage(
)方法,在工作线程发送消息。但是,有没有人想过这种技术是怎么实现的呢?下面我们一起探讨下。

转载请注明出处:http://blog.csdn.net/lowprofile_coding/article/details/72580044

先上图,让大家好理解下handler机制:

介绍

前面的内容对Handler做了介绍,也讲解了如何使用handler,但是我们并不知道他的实现原理。本文从源码的角度来分析如何实现的。

首先我们得知道Handler,Looper,Message Queue三者之间的关系

  • Handler封装了消息的发送,也负责接收消。内部会跟Looper关联。
  • Looper
    消息封装的载,内部包含了MessageQueue,负责从MessageQueue取出消息,然后交给Handler处理
  • MessageQueue
    就是一个消息队列,负责存储消息,有消息过来就存储起来,Looper会循环的从MessageQueue读取消息。

澳门新葡萄京官网注册 1
handler机制示例图

源码分析

当我们new一个Handler对象的时候,看看他的构造方法里面做了什么.

public Handler(Callback callback, boolean async) {
    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;
}

从源码中我们看到他会调用Looper.myLooper方法获取一个Looper对象,然后从Looper对象获取到MessageQueue对象。

上面一共出现了几种类,ActivityThread,Handler,MessageQueue,Looper,msg(Message),对这些类作简要介绍:

Looper myLooper()

跟进去看看Looper.myLooper()方法做了什么。这是一个静态方法,可以类名.方法名直接调用。

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

这个方法里面就一行代码,从sThreadLocal中获取一个Looper对象,sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。底层是ThreadLocalMap,既然是Map类型那肯定得先set一个Looper对象,然后我们才能从sThreadLocal对象里面get一个Looper对象。

ActivityThread:程序的启动入口,为什么要介绍这个类,是因为该类就是我们说的主线程,它对Looper进行操作的。

ActivityThread main()

说到这里得给大家介绍一个新的类ActivityThread,ActivityThread类是Android
APP进程的初始类,它的main函数是这个APP进程的入口。我们看看这个main函数干了什么事情。

public static final void main(String[] args) {
        ------
        Looper.prepareMainLooper();
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();
        -----
}

在第二行代码调用Looper.prepareMainLooper()方法,第13行调用了Looper.loop()方法。

Handler:字面意思是操控者,该类有比较重要的地方,就是通过handler来发送消息(sendMessage)到MessageQueue和
操作控件的更新(handleMessage)。handler下面持有这MessageQueue和Looper的对象。

Looper prepareMainLooper()

继续跟进Looper.prepareMainLooper()方法,在这个方法中第一行代码调用了内部的prepare方法。prepareMainLooper有点像单例模式中的getInstance方法,只不过getInstance会当时返回一个对象,而prepareMainLooper会新建一个Looper对象,存储在sThreadLocal中。

public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

MessageQueue:字面意思是消息队列,就是封装Message类。对Message进行插入和取出操作。

Looper prepare()

继续跟进prepare方法,看第5行代码,新建了一个Looper对象,调用sThreadLocal.set方法把Looper对象保存起来。看到这里我想聪明的你们肯定明白了为什么new
Handler对象的时候调用Looper.myLooper()方法能从sThreadLocal对象中取到Looper对象。

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

Message:这个类是封装消息体并被发送到MessageQueue中的,给类是通过链表实现的,其好处方便MessageQueue的插入和取出操作。还有一些字段是(int
what,Object obj,int arg1,int
arg2)。what是用户定义的消息和代码,以便接收者(handler)知道这个是关于什么的。obj是用来传输任意对象的,arg1和arg2是用来传递一些简单的整数类型的。

Looper 构造方法

文章开头我们就讲到Looper内部包含了MessageQueue,其实就是在new
Looper对象的时候就new了一个MessageQueue对象。

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

下面,我们按照启动顺序来进行源码分析:

Looper loop()

ActivityThread类main方法中调用了Looper的两个方法,前面我们解释了prepareMainLooper(),现在来看第二个方法loop()。

public static void loop() {
    final Looper me = myLooper();//获取Looper对象
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;//从Looper对象获取MessageQueue对象

    // 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 (;;) {//死循环  一直从MessageQueue中遍历消息
        Message msg = queue.next(); // might block
        if (msg == null) {
            return;
        }

        // This must be in a local variable, in case a UI event sets the logger
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        try {
            //调用handler的dispatchMessage方法,把消息交给handler处理
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }

        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.recycleUnchecked();
    }
}

这个方法的代码呢比较多。我都给代码加上了注释。其实就是一个死循环,一直会从MessageQueue中取消息,如果取到了消息呢,会执行msg.target.dispatchMessage(msg)这行代码,msg.target就是handler,其实就是调用handler的dispatchMessage方法,然后把从MessageQueue中取到的message传入进去。

澳门新葡萄京官网注册 2

Handler dispatchMessage()

public void dispatchMessage(Message msg) {
    //如果callback不为空,说明发送消息的时候是post一个Runnable对象
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {//这个是用来拦截消息的
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);//最终调用我们重写的handleMessage方法
    }
}

这个方法对消息做最后处理,如果是post类型调用handleCallback方法处理,如果是sendMessage发送的消息。看我们有没有拦截消息,如果没有最终调用handleMessage方法处理。

从上面可以看出,ActivityThread类是用来启动Android的,其源码为:

Handler handleCallback()

看到这里我们知道为什么post一个Runnable对象,run方法执行的代码在主线程了吧,因为底层根本就没有开启线程,就只是调用了run方法而已。

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

前面我们从创建handler对象开始,以及创建Looper,创建MessageQueue的整个流程,现在来分析下,当我们调用post以及sendMessage方法时,怎么把Message添加到MessageQueue。

澳门新葡萄京官网注册 3
ActivityThread类:

Handler post()

调用了getPostMessage方法,把Runnable传递进去。

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

接下来,我们看到Looper类了,我们进去看看里面的源码实现:

Handler getPostMessage()

首先调用Message.obtain()方法,取出一个Message对象,这个方法之前有讲过,然后把Runnable对象赋值了Message对象的callback属性。看到这里我们也明白了dispatchMessage方法为什么要先判断callback是否为空了吧。

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

首先,我们看看里面有哪些字段:

Handler enqueueMessage()

在post方法里面调用了sendMessageDelayed方法,其实最终调用的是enqueueMessage方法,所以我这里就直接看enqueueMessage方法源码。第一行代码就把handler自己赋值给messgae对象的target属性。然后调用MessageQueue的enqueueMessage方法把当前的Messgae添加进去。

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

澳门新葡萄京官网注册 4 Looper的内部属性

总结

总结:handler负责发送消息,Looper负责接收Handler发送的消息,并直接把消息回传给Handler自己。MessageQueue就是一个存储消息的容器。

      Android开发666 - 安卓开发技术分享
             扫描二维码加关注

澳门新葡萄京官网注册 5

Android开发666

然后我们迫不及待地要想去看看prepareMainLooper方法,到底干了什么

澳门新葡萄京官网注册 6

Looper.prepareMainLooper()方法

这里我们可以看到,prepareMainLooper是为了设置一个持有消息队列和消息序列器的Looper进去ThreadLocal。接下来我们看看loop方法吧:

澳门新葡萄京官网注册 7

Looper.loop()方法

我们可以看到loop方法中,会取出内部的消息序列器,并且迭代里面的消息,根据消息的target分发消息(到handleMessage方法中)。如果你有疑问,你应该是不清楚Looper的MessageQueue为什么会有Message。那么我们就马上去看,到底是哪里添加消息的。话说,到了这里我也好像没有分析到和我们handler相关的操作吧。因为你和我都知道handler的作用是sendMessage和handleMessage,所以我们知道,Looper中的消息序列器的消息体,肯定是从sendMessage中添加进去的。不墨迹,我们马上进入Handler的源码分析。

首先,我们先看看Handler的字段:

澳门新葡萄京官网注册 8

Handler的字段

接着,我们看看Handler的构造方法,我们可以看到,Handler有两类构造方法(别看到6个,它们都是往这两种方法调用的):

澳门新葡萄京官网注册 9

Handler的构造方法

接着,我们要进入Handler.dispatchMessage()方法,因为我们要解释上面刚刚Looper.loop方法。dispatchMessage的方法很简单,只有三个方向,其源码为:

澳门新葡萄京官网注册 10

Handler.dispatchMessage()方法

到这里为止,执行代码就结束了。那么问题来了,消息从哪里来的?带着这个疑问,我们马上进入Handler.sendMessage()逻辑去看看,其源码是:

澳门新葡萄京官网注册 11

Handler.sendMessage()方法

好不容易找到了发送消息的逻辑并理解了,但是还要去壳,在MessageQueue中分析了,首先,我们回顾下,消息序列器是在Looper.prepare()中初始化的。MessageQueue源码,构造方法很简单:

澳门新葡萄京官网注册 12

MessageQueue构造方法

然后我们再到达MessageQueue.enqueueMessage()方法中看源码:

澳门新葡萄京官网注册 13

MessageQueue.enqueueMessage()方法

这个是发送消息的最终执行代码,就是把消息放进消息序列器。在Looper.loop()方法中,我们是需要不断从消息序列器中取出消息的。其过程也是我们可以进去MessageQueue.next()的源码中看看:

澳门新葡萄京官网注册 14

MessageQueue.next()方法

这样,整个过程就完成了。在这些执行过程中,Message是它们的物件。我们可以看看Message的结构:

澳门新葡萄京官网注册 15

Message的字段

除此之外,Message的数据结构是基于链表的,方法都很简单的,我就不贴出来了。

总结一下,其实就是用一个ThreadLocal来存储对象,然后在执行的时候,能够保证对象的不变形,这样就能达到在主先线程更新UI了。

发表评论

电子邮件地址不会被公开。 必填项已用*标注