消息机制

异步消息处理

一、Looper

Looper负责的就是创建一个MessageQueue,然后进入一个无限循环体不断从该MessageQueue中读取消息,而消息的创建者就是一个或多个Handler 。

在构造方法中,创建了一个MessageQueue(消息队列)。

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

方法1. static void prepare() 静态的方法,准备
ThreadLocal中添加进一个新的对象,sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。prepare()中判断了当前线程的 Looper 对象是否为null,不为 null则抛出异常。这也就说明了一个线程Looper.prepare()方法不能被调用两次,同时也保证了一个线程中只有一个Looper实例

static final ThreadLocal sThreadLocal = new ThreadLocal();
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));
}

方法2. loop() 方法

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

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);把消息交给msg的target的dispatchMessage方法去处理。
        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();
    }
}

Looper 的静态方法 prepare() 中新建了一个 Looper 对象,Looper 的构造方法中初始化了 MessageQueue(新建) 和 Thread (当前线程)。这两个对象是 Looper 对象持有的,每个 Looper 对象中都有一个 MessageQueue 和 当前线程对象

prepare() 中将新建的 Looper 对象添加到了 ThreadLocal 对象中,这个对象是
static final ThreadLocal sThreadLocal = new ThreadLocal();
ThreadLocal 在类的最初就会实例化,在存储 Looper 的时候会以当前线程的对象作为一个参数,在取Looper
时也会通过当前线程来取

prepare() 方法中会判断当前线程是否已经绑定了 Looper 对象,如果绑定了则会抛出
throw new RuntimeException("Only one Looper may be created per thread");
并且在取 Looper 时也会根据当前线程判断是否绑定了 Looper ,如果没有绑定则会抛出
throw new IllegalStateException("No Looper; Looper.prepare() wasn't called on this thread.");
通过这个过程,保证了每个线程只能绑定一个 Looper ,并且每个 Looper 都有一个 MessageQueue 对象

Looper.myLooper()获取了当前线程保存的 Looper 实例,然后在又获取了这个 Looper 实例中保存的
MessageQueue(消息队列),这样就保证了 handler 的实例与我们 Looper 实例中 MessageQueue 关联上了。

Looger.getMainLooper(); 获取主线程的 Looper 对象,主线程会自动调用 Looper.prepareMainLooper() 方法
完成 Looper 对象的绑定,并将该 Looper 对象赋值给一个静态的 Looper 变量,在调用 getMainLooper() 方法
时将该 Looper 对象返回。
Looper.myLooper() 方法是获取当前线程的 Looper 对象。

Looper主要作用:

  1. 与当前线程绑定,保证一个线程只会有一个Looper实例,同时一个Looper实例也只有一个MessageQueue。
  2. loop()方法,不断从MessageQueue中去取消息,交给消息的target属性的dispatchMessage去处理。
    好了,我们的异步消息处理线程已经有了消息队列(MessageQueue),Looper 负责轮询消息队列,下面分析发送消息的 Handler

二、Handler


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

Handler 对象中有一个 Looper 对象和一个 MessageQueue 对象,这两个属性都是final 的
在创建一个 Handler 对象的时候,如果当前线程没有绑定 Looper 对象,则会抛出异常
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
所以在一个线程中创建 Handler 的时候当前线程必须调用 Looper.prepare(); 方法

然后看我们最常用的sendMessage方法,方法最后调用了sendMessageAtTime,在此方法内部有直接
获取 MessageQueue 然后调用了 enqueueMessage 方法,我们再来看看此方法: enqueue : 入队

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

enqueueMessage 中首先为 meg.target 赋值为this,【Looper的loop方法会取出每个msg然后交给
msg.target.dispatchMessage(msg) 去处理消息】,也就是把当前的handler作为msg的 target 属性。最终
会调用 queue 的 enqueueMessage 的方法,也就是说 handler 发出的消息,最终会保存到消息队列中去。enqueueMessage 方法中使用 synchronize 锁 MessageQueue 对象,保证不同线程插入数据时的同步问题。

Looper会调用prepare()和loop()方法,在当前执行的线程中保存一个Looper实例,这个实例会保存一个
MessageQueue对象,然后当前线程进入一个无限循环中去,不断从MessageQueue中读取Handler发来的消息。
然后再回调创建这个消息的handler中的dispathMessage方法,下面我们赶快去看一看这个方法:

public void dispatchMessage(Message msg) {  
    if (msg.callback != null) {  
        handleCallback(msg); // 使用创建 Message 时构造方法中的 Runnable 处理消息
    } else {  
        if (mCallback != null) {  
            if (mCallback.handleMessage(msg)) {  // 使用创建 Handler 时构造方法中的 Handler.Callback 处理消息
                return;  
            }  
        }  
        handleMessage(msg);  // 重写的处理消息方法处理
    }  
} 

这个流程已经解释完毕,让我们首先总结一下

  1. 首先Looper.prepare()在本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象;
    因为Looper.prepare()在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个。
  2. Looper.loop()会让当前线程进入一个无限循环,不端从MessageQueue的实例中读取消息,然后回调
    msg.target.dispatchMessage(msg)方法。
  3. Handler的构造方法,会首先得到当前线程中保存的Looper实例,进而与Looper实例中的MessageQueue想关联。
  4. Handler的sendMessage方法,会给msg的target赋值为handler自身,然后加入MessageQueue中。
  5. 在构造Handler实例时,我们会重写handleMessage方法,也就是msg.target.dispatchMessage(msg)最终调用的方法。

好了,总结完成,大家可能还会问,那么在Activity中,我们并没有显示的调用Looper.prepare()和Looper.loop()方法,
为啥Handler可以成功创建呢,这是因为在Activity的启动代码中,已经在当前UI线程调用了Looper.prepareMainLooper()和Looper.loop()方法。

关于Handler处理消息的方式

  1. 创建Message对象时,指定Runnable对象,
    例如Message.obtain(Handler handler, Runnable callback)
  2. 创建Handler.Callback实现类对象,并作为创建Handler的构造方法的参数
  3. 自定义类继承自Handler,并重写handlerMessage()方法
    以上3种方法的执行顺序:如果存在方式1,则由方式1直接处理;如果存在方式2,
    则方式2处理消息,且,如果方式2返回true,则处理完毕,否则,方式3也会处理消息。

Handler.post(); // 等多久执行... run() 方法中的代码

mHandler.post(new Runnable() {  
    @Override      
    public void run(){  
        og.e("TAG", Thread.currentThread().getName());  
        mTxt.setText("test");  
    }  
});  

然后run方法中可以写更新UI的代码,其实这个Runnable并没有创建什么线程,而是发送了一条消息,下面看源码:

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

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

可以看到,在getPostMessage中,得到了一个Message对象,然后将我们创建的Runable对象作为callback属性,赋值给了此 message.

  • 注:产生一个Message对象,可以new ,也可以使用Message.obtain()方法;两者都可以,但是更建议使用obtain方法,
    因为Message内部维护了一个Message池用于Message的复用,避免使用new 重新分配内存。
    最终和handler.sendMessage一样,调用了sendMessageAtTime,然后调用了enqueueMessage方法,给msg.target赋值为 handler,最终加入MessagQueue.

  • msg的 callback 和target都有值,那么会执行哪个呢?
    如果 callback 不为null,则执行callback回调,也就是我们的Runnable对象

  • Handler 对象创建之后可以在任何线程中发消息,最终消息的处理都将回到 创建 Handler 时使用的 Looper 所在的线程处理。所以在子线程中可以使用主线程中创建的 Handler 对象发消息,在主线程中处理消息。
  • Activity 中可以创建多个 Handler ,处理消息时就调用 msg.targe 也就是 Handler 来处理.Looper 将消息发送给发送消息时使用的 Handler 对象。
    子线程不可以直接创建 Handler, 必须在子线程先调用 Looper.prepare();线程中调用 Looper.loop(); 方法后才会开启轮循

  • 一个线程中只能有一个 Looper ,也就是只能有一个 MessageQueue ,可以有多个 Handler。一个 Handler 可以在不同的线程中发送消息,但是消息的处理都是在创建 Handler 时使用的 Looper 所在的线程。

参考:http://blog.csdn.net/lmj623565791/article/details/47079737

你可能感兴趣的:(消息机制)