android之Looper

Looper是什么？

　　刚开始对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, callprepare() in the thread that is to run the loop, and then loop() to have it process messages until the loop is stopped.

大致是说：1）Looper是为Thread工作的2）为Thread工作提供一个消息循环3）线程默认情况下没有Looper，想要创建Looper需要我们在此线程中先调用prepare()然后再调用loop()开始循环直到loop停止。

深入Looper

如上所说，Looper为Thread提供了一个消息循环，通过此循环Thread可以不断的取出消息并处理。线程默认情况下没有Looper，但android的主线程却不一样了，系统默认为主线程设置了一个looper，所以如果我们在主线程中创建Handler时不需要创建looper.说到这不妨先说一下handler与looper的关系。handler是为了发送和处理消息的。发送到looper所管理的消息队列中。一般情况下，我们是不需要自己创建looper的，我们只有在需要实现子线程与子线程之间的通信时才需要自己创建looper，因为这样的话我们就需要在其中一个子线程中new 一个handler对象，而这样就需要我们为此子线程先创建一个looper,看官方文档中的例子：

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

如果我们没有创建looper就直接new handler会得到这样的错误："Can't create handler inside thread that has not called Looper.prepare()"

 

源码分析

  
public class Looper {
//用来保存looper
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    //主线程looper对象
    private static Looper sMainLooper;  // guarded by Looper.class
    //looper操作的消息队列
    final MessageQueue mQueue;
    //looper依附的线程
    final Thread mThread;
   
   //实例化一个允许quit的looper
    public static void prepare() {
        prepare(true);
    }

    //实例化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，不允许quit
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

    public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }
    
    //循环体，在此循环体中进行消息的循环，并调用handler的dispatchMessage方法进行消息的处理
    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);

            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
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

    public static MessageQueue myQueue() {
        return myLooper().mQueue;
    }

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

    public void quit() {
        mQueue.quit();
    }

    /**
     * Return the Thread associated with this Looper.
     */
    public Thread getThread() {
        return mThread;
    }

    /** @hide */
    public MessageQueue getQueue() {
        return mQueue;
    }
}