Android多线程基础 解析Handler机制

解析异步消息处理机制

Android的异步消息处理主要由4个部分组成:Message,Handler,MessageQueue以及Looper。

1.Message:是在线程之间传递信息,它可以在内部携带少量信息,用于在不同线程之间交换数据。
2.Handler:是处理者的意思,它主要用于发送和处理消息的。
3.MessageQueue:是消息队列的意思,他主要用于存所有通过Handler发送的消息,这部分消息为一直存在于消息队列中,等待被处理。每个线程只会有一个MessageQueue对象。
4.Looper:每个线程MessageQueue的管理者。调用Looper.loop()方法后,会进入到一个无线循环中,只要一发现MessageQueue中存在一条消息,就会将他取出,并且传递到Handler的handleMessage()方法中,每个线程也只会有一个Looper对象。

异步消息处理流程:

需要在主线程创建一个Handler对象,并重写handleMessage( )方法,然后在子线程需要更新UI的时候,创建一个Message对象,并通过Handle将信息发送,之后这条消息会被添加到MessageQueue中等待被处理,而Looper会一直循环的从MessageQueue中取出消息,最后分发回调handleMessage( )方法中。而此时操作也就变换到了主线程,因此可以放心的更新UI了。


Android多线程基础 解析Handler机制_第1张图片
.png

问题一:在子线程想更新UI的时候,为什么Handler必须声明在主线程呢?

解决这个问题之前,要先知道,UI线程的消息循环是在ActivityThread.main方法中创建的,该函数为Android应用程序入口,代码如下:

    Looper.prepareMainLooper();//1.创建消息循环Looper
   ActivityThread thread = new ActivityThread();
    thread.attach(false);
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }
    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    Looper.loop();  //2.开启消息循环
    throw new RuntimeException("Main thread loop unexpectedly exited");

由这段代码可以知道,当应用程序创建启动时, Looper.prepareMainLooper();就已经帮我们创建了Looper,并且开启了消息循环。
而当我们在子线程执行耗时操作后,就需要Handler将一个消息Post到UI线程,然后在handleMessage( )处理,然而每个Handler都会关联一个消息队列,消息队列被封装在Looper中。

问题二:既然Handler关联了线程以及消息队列,那么他们是如何关联的呢?摘取一段代码

public Handler( ){
     //省略上面代码
        mLooper = Looper.myLooper();//获取Looper
        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;
}

从以上源码可知,Handler默认函数会获取Looper对象,还有消息队列,那么他们是如何获取消息对象的呢?进去 myLooper,如下:

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

发现它是 sThreadLocal.get( )获取的,那么它又是什么时候存了 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));//创建了Looper对象并赋值给了sThreadLocal
    }

这样 Looper就和线程关联上了,不同的线程就不能访问对方的消息队列,再看回来Handler的默认构造函数, mQueue = mLooper.mQueue;//获取消息队列,让Looper对象和消息队列关联,而Handler又和Looper关联,Looper又与线程关联,那么他们就关联起来了。
那么问题一的答案就出来了:
默认情况下,消息队列只有一个即上面分析的主线程的消息队列它在 Looper.prepareMainLooper();方法中创建,而Handler又和Looper关联,Looper又与线程(主线程)关联,此时只有Handler声明下主线程,handleMessage才会在主线程执行,在主线程更新UI才是安全的。

问题三:创建Looper后,是如何执行消息循环的?

在ActivityThread.main方法中进去看Looper.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(); //获取消息
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            //....省略
            try {
                msg.target.dispatchMessage(msg);//消息处理
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
             //....省略
            msg.recycleUnchecked();//回收消息
        }
    }

在 msg.target.dispatchMessage(msg)中,msg是Message类型进去 Message

public final class Message implements Parcelable {
  Handler target;
  Runnable callback;
  Message next;
}

可以知道target是一个Handler,在上一篇中知道,我们通过知道了Handler将消息发送给消息队列,然后在这里消息队列又会把消息分发给Handler处理。
看下消息分发处理:

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

从上面的Message类型可以知道callback是Runnable类型的,在分发的时候回进行判断,不为空由 handleCallback(msg);处理,为空时 handleMessage(msg);处理,而 handleMessage(msg);是一个空方法,我们平时写的更新UI操作也是在这里面执行的。其实他就是Handler分发的两种方式,一种Post(Runnable callback),一种sendMessage:

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

这两种最后都是会执行sendMessageDelayed()方法:

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

继续进去看sendMessageAtTime()方法。

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

继续进去看enqueueMessage()方法。

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);//将消息插入消息队列
    }

msg.target = this设置当前Handler对象
因此可以知道不管是Pos方法还是sendMessage方法,最后Handler都会把消息加到消息队列MessageQueue中。然后Looper会不断的去获取消息,并且调用 Handle的dispatchMessage的消息也就是( msg.target.dispatchMessage(msg);//消息处理),这样消息就会不停的被产生,被添加,和被处理。这就是消息的处理机制

你可能感兴趣的:(Android多线程基础 解析Handler机制)