Android 之 Handler机制

 Handler机制

一张图搞定一切：

 

1.在你的应用启动的时候会执行ActivityThread中的main方法，在main中调用了Looper.prepareMainLooper()；在内部有会调用Looper的prepare()方法，在调用ThreadLocal.set(new Looper());在Looper的构造函数中有创建了MessageQueue；这两个对象的构造函数是默认权限的；

		public static final void main(String[] args) {
		        ....
				// 1.主线程创建Looper 
		        Looper.prepareMainLooper();
		        if (sMainThreadHandler == null) {
		            sMainThreadHandler = new Handler();
		        }
		
		        ActivityThread thread = new ActivityThread();
		        thread.attach(false);
		
		        if (false) {
		            Looper.myLooper().setMessageLogging(new
		                    LogPrinter(Log.DEBUG, "ActivityThread"));
		        }
		
		        Looper.loop();

	public static final void prepare() {
	        if (sThreadLocal.get() != null) {
	            throw new RuntimeException("Only one Looper may be created per thread");
	        }
			// 3、在主线程中设置Looper， new Looper()里面创建了一个MessageQueue
	        sThreadLocal.set(new Looper());
    
   public static final void prepareMainLooper() {
              // 2、调用prepare
				prepare();
		        setMainLooper(myLooper());
		        if (Process.supportsProcesses()) {
		            myLooper().mQueue.mQuitAllowed = false;
		        }
    }

2.紧接着调用了Looper.loop()；在这个方法里面有一个死循环，但是是阻塞的，从MessageQueue中取消息，取不到就阻塞在next方法里面，阻塞的本质是现实是使用了Linux的管道机制，管道都不到消息的时候就阻塞了；
 

		 public static final void loop() {
		       	...
		        while (true) {
					// 取消息，如果没有消息，就阻塞
		            Message msg = queue.next(); // might block
		            ...

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

从上面的代码看到，读到消息的时候就会交给msg.target就是handler的dispatchMessage（msg）方法，这个方法在调用了我们熟悉 handlerMessage（msg）方法；
 

3.创建handler的有两种方式，有参构造和无参构造：

无参构造的时候会通过Looper.myLooper()获取Looper和messageQueue供handler使用；

有参构造的时候会传进去一个Looper，当然你可以调用Looper.myLooper穿进去，但是仅限主线程中；如果在子线程中的需要调用Looper.getMainLooper(）；因为这个Looper在主线程中创建的和主线程绑定了，子线程中没有的，Looper.myLooper在子线程会返回一个null；

当然也可以在子线程创建一个Looper，调用Looper.prepare()方法，ThreadLoacl会根据当前线程有没有绑定一个Looper做出反应，如果有则会抛出异常，如果没有回给当前线程绑定一个Looper；这个会在HandlerThread中用到；不过使用它的场景很少基本用不到；

 

4.那么handler是如何发送消息的呢？
调用了queue.enqueueMessage();消息按照时间顺序插入到消息队列中，然后调用唤醒主线程的方法；

		public boolean sendMessageAtTime(Message msg, long uptimeMillis)
		{
		        ....
					// 把Message的target置为当前发送的Handler，以便Looper取到message后根据target把message分发给正确的Handler
					msg.target = this;
					// 往队列里面添加Message
		            sent = queue.enqueueMessage(msg, uptimeMillis);
		        ....
        }

	final boolean enqueueMessage(Message msg, long when) {
        ...
            Message p = mMessages;
            if (p == null || when == 0 || when < p.when) {
				// 当前发送的message需要马上被处理调，needWake唤醒状态置true
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked; // new head, might need to wake up
            } else {
				// 当前发送的message被排队到其他message的后面，needWake唤醒状态置false
                Message prev = null;
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                needWake = false; // still waiting on head, no need to wake up
            }
        }
		// 是否唤醒主线程
        if (needWake) {
            nativeWake(mPtr);
        }
        return true;

当调用了nativeWake后就回到了第二步中的next方法，结束阻塞，执行下面的消息处理；

ps：

• linux中的管道机制是一种特殊的文件，实现进程间通信的，有两个文件描述符，一个读，一个写；
• android主线程是阻塞的，可以想想一个main方法不阻塞的话就运行结束了，程序结束了还得了；
• 所有关于主线程的操作都是使用了looper和messagequeue方式实现的；

 

用HandlerThread创建线程

 

　　上面说明的是在非主线程中，如果要使用Handler的话，需要使用上面的说法。其实Android提供了更加简洁方便的方式使用HandlerThread来创建新的线程。
　　如果已经知道在新线程中需要使用Handler对象，则可以用HandlerThread来创建新线程。可以调用HandlerThread对象的getLooper方法获取这个线程关联的Looper对象。因为在HandlerThread中系统调用了一下Looper.prepare()，在该线程中创建了一个looper设置给了ThreadLocal和该线程相关联；然后将这个Looper对象传递给Handler对象。但是通过该handler在子线程中发消息回调的handlerMessage方法还是在子线程中的，不能刷新UI的；
　　HandlerThread提供了一个方法onLooperPrepared回调方法，可以重写这个方法，进行一些初始化的工作，比如构造Handler对象（此时，可以不传递Looper对象）。这个方法处在Looper.prepare()和Looper.loop()方法之间。