Looper、Handler和Thread的关系

1.如何为Thread创建消息循环

Threads by default do not have a message loop associated with them

Thread默认是没有绑定消息循环的，主线程是个例外，稍后讨论主线程。

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.

创建消息循环的第一步是new Looper()，但是由于只有一个构造方法且是private，所以应调用prepare()来new出来

    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

    public static void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

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

sThreadLocal中保存了Looper的实例，能保证prepare在同一个Thread中只能被调用一次。

Looper的构造方法也值得一看：

它需要创建一个消息队列，同时需要保存当前Thread到成员变量mThread中。

所以，Looper、MessageQueue和Thread是一对一的关系：

一个Thread最多只能有一个Looper实例（也可以没有，主线程默认有一个，非主线程默认没有）；

当你调用Looper.prepare()时，它就会创建一个Looper实例，同时与当前Thread进行绑定。

一个Looper有且只有一个MessageQueue。

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

    public Thread getThread() {
        return mThread;
    }

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

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

创建消息循环的第二步是调用loop()方法使Thread进入消息循环。

在一个while循环中，不断地从消息队列中取出Message，交给此Message绑定的Hanler却分发处理。

这个循环退出只有一种方式：某个Message的target为空。

这只有调用quit方法时才会发生，其它情况下，每个Message都会与某个Handler实例绑定。

    public static void loop() {
        Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        MessageQueue queue = me.mQueue;
        
        while (true) {
            Message msg = queue.next(); // might block
            if (msg != null) {
                if (msg.target == null) {
                    // No target is a magic identifier for the quit message.
                    return;
                }

                msg.target.dispatchMessage(msg);              
                msg.recycle();
            }
        }
    }

    public void quit() {
        Message msg = Message.obtain();
        // NOTE: By enqueueing directly into the message queue, the
        // message is left with a null target.  This is how we know it is
        // a quit message.
        mQueue.enqueueMessage(msg, 0);
    }

下面是一个很好的示例代码：

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

2.消息的处理

msg.target.dispatchMessage(msg);

每个Message的target都指向一个Handler实例，所以处理消息是有Handler的dispatchMessage方法来处理

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

当调用Hanlder的postXXX方法时，都会传递过来一个Runnable对象，这个Runnable对象被封装为callback，在消息队列循环轮到此消息后，handleCallback直接调用此Runnable的run方法。

mCallback是在Hanlder的构造方法中传递进来的，很少见到如此使用它。

最后则是每个Handler实例都要实现的handleMessage方法。

其实，某个Message最终是在哪个线程中被处理，与这个Message中target所指向的Handler有关，进一步，是与这个Handler绑定的Looper有关，更进一步，是这个Looper绑定的Thread。

看Handler的构造方法：

    public Handler() {
        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 = null;
    }

    public Handler(Looper looper) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = null;
    }

这里主要关注与之绑定的Looper，无参数的构造方法中，会通过Looper.myLooper()方法拿到Looper实例，这个之前提到过，它会返回当前线程的Looper（同样地，这个线程应该有Looper，所以要么是主线程，则一定会有；要么是其它线程，那么一定要调用Looper.prepare()之后了，否则会有异常抛出）；另一种则是在构造Handler时传入Looper，因此这种情形下，此Looper绑定哪个线程，则handlerMessage则在哪个线程中执行。

看个简单例子：

public class MainActivity extends Activity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		HandlerThread ht = new HandlerThread("thread_test");
		ht.start();

		Handler handler = new Handler(ht.getLooper()){
			public void handleMessage(Message msg) {
				System.out.println("Handler.handleMessage: getId = " + Thread.currentThread().getId());
				System.out.println("Handler.handleMessage: getName = " + Thread.currentThread().getName());
			}
		};

		System.out.println("Activity.onCreate: getId = " + Thread.currentThread().getId());
		System.out.println("Activity.onCreate: getName = " + Thread.currentThread().getName());

		handler.sendEmptyMessage(0);
	}
}

I/System.out( 2737): Activity.onCreate: getId = 1
I/System.out( 2737): Activity.onCreate: getName = main
I/System.out( 2737): Handler.handleMessage: getId = 174
I/System.out( 2737): Handler.handleMessage: getName = thread_test

通过运行程序后输出的log可以确定，handleMessage方法是在thread_test这个新线程中执行的，而不是在主线程中，UI线程name为main。

也不难猜测，如果只是在主线程中通过new Handler方法，那么其实还是在主线程中执行handleMessage。

所以，如果希望通过Handler执行某些耗时工作的话，一定要新创建一个线程，在新线程中构造消息循环，然后把Looper对象交给Handler。不这样的话，始终还是会在主线程执行耗时操作。

当有此类需求时，HandlerThread是个不错的类，可以帮我们更容易实现。使用方法如上。

系统服务PackageManagerService就是这么处理的。

3.关于主线程

每个应用程序都运行在单独的进程中，进程名称就是包名。每个应用程序都有一个ActivityThread实例，它就运行在该进程的主线程中。

我们既然说主线程默认就有一个消息循环，那么就看它是如何实现的，有和不同：

public static void main(String[] args) {
    Process.setArgV0("<pre-initialized>");

    Looper.prepareMainLooper();

    if (sMainThreadHandler == null) {
        sMainThreadHandler = new Handler();
    }

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

其实与我们之前提到的没多大差异：Looper.prepareMainLooper();   然后是Looper.loop();

所以，主线程之所以有消息循环，是因为系统已为每个应用程序创建了消息循环。但它的特别在于调用的是prepareMainLooper而非prepare。

public static void prepareMainLooper() {
    prepare();
    setMainLooper(myLooper());
    myLooper().mQueue.mQuitAllowed = false;
}

private static Looper mMainLooper = null;  // guarded by Looper.class
private synchronized static void setMainLooper(Looper looper) {
    mMainLooper = looper;
}
public synchronized static Looper getMainLooper() {
    return mMainLooper;
}

可以看到它与prepare相比，只是多了两步：一是把当前创建的Looper保存到成员变量mMainLooper中，二是设置对应的消息队列不允许quit。

public class MainActivity extends Activity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		System.out.println("Activity.onCreate: getId = " + Thread.currentThread().getId());
		System.out.println("Activity.onCreate: getName = " + Thread.currentThread().getName());

		new Thread() {
			public void run() {

				System.out.println("new Thread: getId = " + Thread.currentThread().getId());
				System.out.println("new Thread: getName = " + Thread.currentThread().getName());

				Looper.prepare();
				Handler mHandler = new Handler() {
				//Handler mHandler = new Handler(Looper.getMainLooper()) {
					public void handleMessage(Message msg) {
						System.out.println("new Thread handleMessage: getId = " + Thread.currentThread().getId());
						System.out.println("new Thread handleMessage: getName = " + Thread.currentThread().getName());
					}
				};

				mHandler.sendEmptyMessage(0);
				Looper.loop();
			}
		}.start();
	}
}

Handler mHandler = new Handler(Looper.getMainLooper())

I/System.out( 3162): Activity.onCreate: getId = 1

I/System.out( 3162): Activity.onCreate: getName = main
I/System.out( 3162): new Thread: getId = 204
I/System.out( 3162): new Thread: getName = Thread-204
I/System.out( 3162): new Thread handleMessage: getId = 1
I/System.out( 3162): new Thread handleMessage: getName = main

Handler mHandler = new Handler()

I/System.out( 3265): Activity.onCreate: getId = 1
I/System.out( 3265): Activity.onCreate: getName = main
I/System.out( 3265): new Thread: getId = 210
I/System.out( 3265): new Thread: getName = Thread-210
I/System.out( 3265): new Thread handleMessage: getId = 210
I/System.out( 3265): new Thread handleMessage: getName = Thread-210
*/

从这个例子可以看出，新线程中的handleMessage是在新线程中执行，我们可以通过getMainLooper方法，把handleMessage放在主线程中去执行。