消息机制实现_源码分析

1.主要涉及到三个类MessageQueue,Looper,Handler.附带一个ThreadLocal
其中Looper类为引擎,ThreadLocal保存所有线程创建的Looper实例,以map(key=Thread,value=Looper对象)形式保存
为何Looper类是引擎?因为Looper维护ThreadLocal和MessageQueue(MessageQueue维护Message,Message维护Handler)

线程中使用消息机制:
 class LooperThread extends Thread {
 public Handler mHandler;
// handler可以在其他线程发送消息给当前线程

 public void run() {
 Looper.prepare();

 mHandler = new Handler() {
 public void handleMessage(Message msg) {
 // process incoming messages here
 }
 };

 Looper.loop();
 }
 }
 

2.入口1:Looper.prepare();实现
static ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
// 管理所有Looper对象

    private static Looper sMainLooper;  // guarded by Looper.class

    final MessageQueue mQueue; // 消息队列

public static void prepare() {

        prepare(true);

    }

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
// 已经在指定线程创建过Looper对象了
throw new RuntimeException("Only one Looper may be created per thread");
}
// (Thread,Looper对象)键值对形式保存正在ThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
// ThreadLocal的put和get方法之前有分析过
}

3.入口2:mHandler = new Handler()

    public Handler() {

        this(null, false);

    }

public Handler(Callback callback, boolean async) {

        ...

        mLooper = Looper.myLooper();

        if (mLooper == null) { // 调用new Handler之前必须调用Looper.prepare创建一个Looper对象

            throw new RuntimeException(

                "Can't create handler inside thread that has not called Looper.prepare()");

        }

        mQueue = mLooper.mQueue;

        mCallback = callback;

        mAsynchronous = async;

    }

/**
* Return the Looper object associated with the current thread.  Returns
* null if the calling thread is not associated with a Looper.
*/
public static Looper myLooper() {
return sThreadLocal.get();
}

2.入口3:Looper.loop();实现

/**

     * Run the message queue in this thread. Be sure to call

     * {@link #quit()} to end the loop.

     */

    public static void loop() {

        final Looper me = myLooper(); // 获取当前线程Looper对象

     

        final MessageQueue queue = me.mQueue;
...

// 死循环

        for (;;) {
// 1.取出消息

            Message msg = queue.next(); // might block           

// 2.处理消息.调用Message保存的Handler对象的handleMessage方法

            msg.target.dispatchMessage(msg);

            msg.recycle(); // Return a Message instance to the global pool

        }

    }

// Handler.java
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
// 默认为空
handleCallback(msg);
} else {
if (mCallback != null) {
// 如果有设置该回调
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
// 默认有实现该方法,默认调用该方法处理消息
}
}

4.入口4:mHandler.sendMessage实现
Handler.java

    public final boolean sendMessage(Message msg)

    {

        return sendMessageDelayed(msg, 0);

    }

   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);
// 本质:调用消息队列的插入消息的函数
}

5.总结

5.1 消息队列机制引入的原因(实现机制):一个线程中执行完任务后,想执行另外一个线程的某段代码(典型例子:线程执行完耗时操作,想更新UI线程中界面显示)
这个本质上是不能实现的.so想出一种方法,使用一个全局的共享List,里面放各种代码片段(Message中run接口函数),然后A线程死循环查询List中是否有message,如果有取出message,并且执行里面的run代码片段.B线程在执行完任务后,发送message到List中,此时A线程查询到该消息,就取出message的run接口函数,执行里面的函数,从而解决上述问题