Looper , Handler, Message

Looper 类, 参考os.Looper.java


ThreadLocal 相当于是一个令牌


使用Looper首先调用的是prepare方法而不是直接调用其构造函数

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

prepare 方法里首先判断令牌ThreadLocal是否已经存在(非空), 那说明当前线程已经存在一个对应的Looper对象


如果令牌不存在, 那么首先创建当前线程的Looper对象, 并设置ThreadLocal这个令牌为非空;
而调用的Looper对象的构造函数,  new Looper(quitAllowed) 其实就是生成一个消息队列对象mQueue , 并关联当前线程mThread
也就是说, 运行了Looper的prepare方法后, 当前线程就会关联一个MessageQueue消息队列

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

ThreadLocal 的令牌功能的实现,  static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
首先ThreadLocal是静态的, 和类相关的有且只有一个,
ThreadLocal<Looper> 表示存储Looper对象
然后通过get() set(obj) 方法判断是否已经存在Looper对象



Handler 参考os.Handler.java


handler 构造函数调用 public Handler(Callback callback, boolean async) 内主要代码

        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;

先看看myLooper() , 调用后返回的就是当前线程对应的Looper对象, 这个Looper对象创建时生成的mQueue作为当前线程(生成handler对象)的消息队列


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




于是Handler, Looper 都对应起来了, 只要是生成了Handler对象, 就会有对应的Looper对象, 并且这个Looper对象有唯一的消息队列


默认情况下worker线程是没有Looper对象的, 当然也就没有消息队列了, 于是worker线程如果要处理消息的话, 就必须先创建looper对象

  * Class used to run a message loop for a thread.  Threads by default do
  * not have a message loop associated with them; to create one, call
  * {@link #prepare} in the thread that is to run the loop, and then
  * {@link #loop} to have it process messages until the loop is stopped.
  * 
  * <p>Most interaction with a message loop is through the
  * {@link Handler} class.
  * 
  * <p>This is a typical example of the implementation of a Looper thread,
  * using the separation of {@link #prepare} and {@link #loop} to create an
  * initial Handler to communicate with the Looper.
  *
  * <pre>
  *  class LooperThread extends Thread {
  *      public Handler mHandler;
  *
  *      public void run() {
  *          Looper.prepare();
  *
  *          mHandler = new Handler() {
  *              public void handleMessage(Message msg) {
  *                  // process incoming messages here
  *              }
  *          };
  *
  *          Looper.loop();
  *      }
  *  }</pre>

   //另外需要注意的是 Activity的MainUI线程默认是有消息队列的。所以在Main Activity中新建Handler时，不需要先调用Looper.prepare() 也不需要调用Looper.loop()。



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(); // 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);

先通过myLooper得到当前线程的looper对象从而获得消息队列
然后一个for无限循环, 从队列里取出next msg , queue.next() 实际是从消息池里取出消息, 而且可能阻塞 . 
如果当前没有msg则退出, 正常获取消息后进行了一些其他操作
然后执行msg.target.dispatchMessage(msg);


那么target是什么呢?我们查看


Message.java 中的定义


 /*package*/ Handler target;     


可见target就是Handler, 那么Handler和msg的target是怎么联系起来的呢?


我们生成消息的时候不是直接调用Message的构造函数而是通过


Message msg = handler.obtainMessage();




//Handler类obtainMessage 方法如下, 它间接帮我们调用Message的构造函数(通过Message.obtain()方法), 并且传递了参数this对象



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





//Message类 obtain(Handler h)



    public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h;


        return m;
    }




// 可见handler的obtainMessage 在调用Message.obtain(this);方法时, 把this对象,也就是本身handler对象传递给了msg
// 于是msg对象的target赋值为handler, 也就是生成msg的这个handler对象
// handler 可以生成多个msg , 一个handler可以对应多个msg




// 消息池中查看是否有msg没有就生成新的msg
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }




msg和handler建立了对应关系后, 我们继续看looper对象的loop方法里面 msg.target.dispatchMessage(msg); 
也就是handler的dispatchMessage方法

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

首先判断msg是否有回调函数, 有的话就执行msg的回调函数
没有msg回调函数的话, 就判断是否有handler的回调函数, 有就执行
msg,handler 的回调函数都没有的话, 就执行handleMessage方法 
所以我们生成handler类时, 要求  Override handleMessage方法, 这样就保证了msg一定被处理




纵观整个的过程, 为了实现worker线程的消息循环,


需要有消息队列, 消息循环, 消息处理


looper 和消息队列是直接关系, looper里面生成线程对应的唯一的消息队列对象


handler 和looper是直接关系, handler的构造函数里面直接赋值looper对象为一个成员变量,
handler获取到looper对象后, 也就获得了looper对象所生成的线程的消息队列, handler在哪创建, looper就在哪个线程?


message 和Handler是直接关系,  因为message是通过handler的 obtainMessage()方法得到的, msg的target成员变量就是生成msg的handler


于是流程如下 , 


1. looper 生成mQueue 也就是线程消息队列, 确保当前线程只有一个消息队列, 只有一个Looper对象


2. 创建handler , 对象生成时, 绑定已经生成的looper , 获取到looper的消息队列mQueue 


3. 有了上面两步就已经有了消息队列了, 紧接着就由handler创建msg, 并让msg绑定本身handler, 然后通过sendMessage把msg放入looper的消息队列, 


4. looper 执行消息循环loop() 取出mQueue里的消息, 并按msg的回调函数,handler的回调函数,handler类handleMessage方法的次序去处理消息








比如在主线程中创建了handler,   存在默认的looper, 不需要去调用prepare.


handler创建后就会自动绑定main线程的looper, 


然后我们启动了子线程, 在子线程中进行了一些操作得到数据等等, 这时就可以在子线程里调用handler.obtainMessage(), 来生成消息, 然后给消息赋值, 并sendMessage(msg)


handler在子线程里对消息的操作, 最终都是把消息放到了主线程的消息队列中, 因为handler是绑定了其所在的线程的looper,


然后主线程会自动去调用loop()方法取出消息, 并去执行主线程中handler定义的handleMessage方法


于是实现了子线程和主线程之间的通讯




//
// handler 的 post方法








线程的实现, 一个是继承Thread类 , 另外是实现Runnable接口,,


Thread类就直接代表一个线程 , 而实现Runnable接口 生成Runnable对象的话,


Runnable 对象不是线程, 是一个线程体, 不能单独直接运行,  只能传递给线程对象, 通过线程对象来启动运行 比如


Thread t = new Thread(r);
t.start();

//Hander.java  post(Runnable r) 方法:




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






//Hander.java  getPostMessage方法: 


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






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




//Hander.java 


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

post(Runnable r) 方法实际上, 首先是调用obtain生成一个message , 然后把给这个msg赋值回调函数 m.callback = r; 最后把带有Runnable对象的msg放入Looper的mQueue消息队列


为什么要这么做呢? 常规的手段我们是通过msg来让worker线程和main线程通讯, 那么就存在一个数据传递, 那么能不能在子线程里, 在一些数据处理完成后直接对main线程进行操作呢?


于是就可以通过这个带有Runnable对象的Message来实现,  把需要对main线程的操作放在runnable对象r里,  主线程里创建handler对象, 绑定主线程的looper, 然后在子线程里, 数据操作完成后,


通过handler的post(r)方法, 生成一个回调函数为r的msg, 并放到handler对应的消息队列中, 也就是主线程中, 然后main线程会调用loop() 并执行这个消息对象的回调函数




比如下面的这个例子, main线程里直接定义了一个handler变量, 然后通过按钮去启动一个TestThread , TestThread里面的run方法里面执行一些worker thread的数据操作后, 生成一个匿名Runnable对象
这个runnable对象最后通过handler.post(r)方法传递给消息队列,然后这个r对象虽然是在子线程里面创建的,  但是实际上这个r对象的run方法是在main线程里被执行, 因为消息都是被handler操作来操作去,
而这个handler是在main线程里创建的, handler绑定的消息队列是main的消息队列, 因此, 消息循环也就在main线程 并按msg的回调函数,handler的回调函数,handler类handleMessage方法的次序去处理消息

    

   private Handler handler = new Handler();




    class TestThread extends Thread {
@Override
public void run() {

//子线程中一些数据操作

Runnable r = new Runnable() {
@Override
public void run() {
String currentThreadName = Thread.currentThread().getName();
System.out.println("runnable 对象当前运行的线程名称是 ====>" + currentThreadName);
//runnable对象通过handler的post方法赋值给了msg的callback
//于是 runnable对象被放在主线程里通过msg的回调函数被执行 , 因此可以直接修改UI
tv.setText("子线程已运行");
}
};
handler.post(r);
}
    }