【济南中心】凯哥兵法之handler机制

概述：

       handler机制，在Android中提供了一种异步回调机制Handler,谷歌规定耗时的操作不能在主线程执行,必须在子线程中执行，否则可能报这个ANR（application not response 应用无响应）。耗时的操作不能放到主线程中执行，必须在子线程中执行，子线程不能够更新UI,只有主线程能够更新UI，引入Handler来解决。

Handler机制的构成：

      Andriod提供了Handler和 Looper 来满足线程间的通信。Handler先进先出原则。Looper类用来管理特定线程内对象之间的消息交     换(MessageExchange)。

Handler:

构造Handler对象来与Looper沟通，以便push新消息到MessageQueue里或者接收Looper从Message Queue取出)所送来的消息,进行处理。

1.     public Handler() {
   
2.         this(null, false);
   
3.     }
   
4.    public Handler(Callback callback, boolean async) {
   
5.         if (FIND_POTENTIAL_LEAKS) {
   
6.             final Class<? extends Handler> klass = getClass();
   
7.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
   
8.                     (klass.getModifiers() & Modifier.STATIC) == 0) {
   
9.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
   
10.                     klass.getCanonicalName());
    
11.             }
    
12.         }
    
13. 
    
14.         mLooper = Looper.myLooper();
    
15.         if (mLooper == null) {
    
16.             throw new RuntimeException(
    
17.                 "Can't create handler inside thread that has not called Looper.prepare()");
    
18.         }
    
19.         mQueue = mLooper.mQueue;
    
20.         mCallback = callback;
    
21.         mAsynchronous = async;
    
22.     }

复制代码

当实例化一个Handler的时候，系统通过Looper.myLooper()获取了当前线程保存的Looper实例，并获取了这个Looper实例中保存的消息队列，这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。

1.         public final boolean sendMessage(Message msg) {
   
2.                 return sendMessageDelayed(msg, 0);
   
3.         }

复制代码

1. public final boolean sendMessageDelayed(Message msg, long delayMillis) {
   
2.      if (delayMillis < 0) {
   
3.           delayMillis = 0;
   
4.      }
   
5.      return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

复制代码

1. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
   
2.      MessageQueue queue = mQueue;
   
3.      if (queue == null) {
   
4.           RuntimeException e = new RuntimeException(this+ " sendMessageAtTime() called with no mQueue");
   
5.           Log.w("Looper", e.getMessage(), e);
   
6.           return false;
   
7.      }
   
8.      return enqueueMessage(queue, msg, uptimeMillis);

复制代码

1.     private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
   
2.      msg.target = this;
   
3.      if (mAsynchronous) {
   
4.           msg.setAsynchronous(true);
   
5.      }
   
6.      return queue.enqueueMessage(msg, uptimeMillis);
   
7.     }

复制代码

Handler对象通过调用sendMessage(Messagemsg)方法，最终通过调用enqueueMessage(MessageQueuequeue, Message msg, long uptimeMillis)方法

将消息发送给消息队列进行处理。

（1）在调用sendMessageAtTime(Messagemsg, long uptimeMillis)方法的时候

       拿到消息队列（在创建Handler对象时获取到的），

（2）当消息队列不为null的时候，再调用处理消息入列的方法：

            enqueueMessage(MessageQueue queue,Message msg, long uptimeMillis)

            这个方法，做了三件事：

                 ①.为消息打上标签：msg.target =this;：将当前的handler对象这个标签贴到传入的message对象上，为Message指定处理者

                 ②.异步处理消息：msg.setAsynchronous(true);，在asyn为true的时候设置

                 ③.将消息传递给消息队列MessageQueue进行处理：queue.enqueueMessage(msg, uptimeMillis);

1.     public void dispatchMessage(Message msg) {
   
2.           if (msg.callback != null) {
   
3.                handleCallback(msg);
   
4.           } else {
   
5.           if (mCallback != null) {
   
6.                if (mCallback.handleMessage(msg)) {
   
7.                     return;
   
8.                }
   
9.           }
   
10.           handleMessage(msg);
    
11.           }
    
12.     }

复制代码

1.     public interface Callback {
   
2.      public boolean handleMessage(Message msg);
   
3.     }

复制代码

1.     public void handleMessage(Message msg) {
   
2.     }

复制代码

（1）依据Callback中的handleMessage(msg)的真假判断是否要处理消息，如果是真则不进行消息分发，则不处理消息，否则进行处理消息

（2）当Callback为null或其handleMessage(msg)的返回值为false的时候，进行分发消息，即调用handleMessage(msg)处理消息

（3）复写其中的handleMessage(Message msg)，对消息进行处理（更新UI）。在创建Activity之前系统启动的时候，先加载ActivityThread这个类，在这个类中的main函数，调用了Looper.prepareMainLooper()方法进行初始化Looper对象，在创建Handler中，会将Looper设置给handler，并随带着MessageQueue对象；

       虽然是在子线程中编写的代码，但是由于传入的是主线程的looper，所以，Looper从MessageQueue队列中轮询获取消息、再进行更新界面的操作都是在主线程中执行的。

Message Queue(消息队列):

  用来存放Handler发来的Message对象 ，将Message以链表的方式串联起来的，通过Looper进行轮询获取,在一个线程中的MessageQueue需要一个Looper进行管理。

1. boolean enqueueMessage(Message msg, long when) {
   
2.      if (msg.isInUse()) {
   
3.           throw new AndroidRuntimeException(msg + " This message is already in use.");
   
4.      }
   
5.      if (msg.target == null) {
   
6.           throw new AndroidRuntimeException("Message must have a target.");
   
7.      }
   
8. 
   
9.      synchronized (this) {
   
10.           if (mQuitting) {
    
11.                RuntimeException e = new RuntimeException(
    
12.                msg.target + " sending message to a Handler on a dead thread");
    
13.                Log.w("MessageQueue", e.getMessage(), e);
    
14.                return false;
    
15.           }
    
16. 
    
17.           msg.when = when;
    
18.           Message p = mMessages;
    
19.           boolean needWake;
    
20.           if (p == null || when == 0 || when < p.when) {
    
21.           // New head, wake up the event queue if blocked.
    
22.           msg.next = p;
    
23.           mMessages = msg;
    
24.           needWake = mBlocked;
    
25.           } else {
    
26.          // Inserted within the middle of the queue.  Usually we don't have to wake
    
27.          // up the event queue unless there is a barrier at the head of the queue
    
28.          // and the message is the earliest asynchronous message in the queue.
    
29.           needWake = mBlocked && p.target == null && msg.isAsynchronous();
    
30.           Message prev;
    
31.           for (;;) {
    
32.                prev = p;
    
33.                p = p.next;
    
34.                if (p == null || when < p.when) {
    
35.                     break;
    
36.                }
    
37.                if (needWake && p.isAsynchronous()) {
    
38.                     needWake = false;
    
39.                }
    
40.           }
    
41.           msg.next = p; // invariant: p == prev.next
    
42.           prev.next = msg;
    
43.        }
    
44. 
    
45.        // We can assume mPtr != 0 because mQuitting is false.
    
46.        if (needWake) {
    
47.             nativeWake(mPtr);
    
48.        }
    
49.    }
    
50.    return true;

复制代码

在消息未被处理且handler对象不为null的时候，进行如下操作（同步代码块中执行）

  （1）将传入的处理消息的时间uptimeMillis赋值为当前消息的when属性。

  （2）将next()方法中处理好的消息赋值给新的消息引用：Message p = mMessages;在next()方法中：不断的从消息池中取出消息，赋值给mMessage，当没有消息发来的时候，Looper的loop()方法由于是阻塞式的，就一直等消息传进来

  （3）当传入的时间为0，且next()方法中取出的消息为null的时候，将传入的消息msg入列，排列在消息队列上，此时为消息是先进先出的否则，进入到死循环中，不断的将消息入列，根据消息的时刻（when）来排列发送过来的消息，此时消息是按时间的先后进行排列在消息队列上的

Looper(消息循环器):

       一个线程可以产生一个Looper对象，由它来管理此线程里的MessageQueue(消息队列)， 一般用到到是prepare和loop两个方法。

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

复制代码

1.     public static void prepare() {
   
2.      prepare(true);
   
3.     }
   
4. 
   
5.     private static void prepare(boolean quitAllowed) {
   
6.      if (sThreadLocal.get() != null) {
   
7.           throw new RuntimeException("Only one Looper may be created per thread");
   
8.      }
   
9.      sThreadLocal.set(new Looper(quitAllowed));
   
10.     }

复制代码

可以看到，系统将一个Looper的实例放入了ThreadLocal，并且判断了sThreadLocal是否为null，这也说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例

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

复制代码

1.     /**
   
2.      * Run the message queue in this thread. Be sure to call
   
3.      * {@link #quit()} to end the loop.
   
4.      */
   
5.     public static void loop() {
   
6.      final Looper me = myLooper();
   
7.      if (me == null) {
   
8.           throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
   
9.      }
   
10.      final MessageQueue queue = me.mQueue;
    
11. 
    
12.      // Make sure the identity of this thread is that of the local process,
    
13.      // and keep track of what that identity token actually is.
    
14.      Binder.clearCallingIdentity();
    
15.      final long ident = Binder.clearCallingIdentity();
    
16. 
    
17.      for (;;) {
    
18.      Message msg = queue.next(); // might block
    
19.      if (msg == null) {
    
20.           // No message indicates that the message queue is quitting.
    
21.           return;
    
22.      }
    
23. 
    
24.      // This must be in a local variable, in case a UI event sets the logger
    
25.      Printer logging = me.mLogging;
    
26.      if (logging != null) {
    
27.           logging.println(">>>>> Dispatching to " + msg.target + " " +
    
28.           msg.callback + ": " + msg.what);
    
29.      }
    
30. 
    
31.      msg.target.dispatchMessage(msg);
    
32. 
    
33.      if (logging != null) {
    
34.           logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    
35.      }
    
36. 
    
37.      // Make sure that during the course of dispatching the
    
38.      // identity of the thread wasn't corrupted.
    
39.      final long newIdent = Binder.clearCallingIdentity();
    
40.      if (ident != newIdent) {
    
41.           Log.wtf(TAG, "Thread identity changed from 0x"
    
42.           + Long.toHexString(ident) + " to 0x"
    
43.           + Long.toHexString(newIdent) + " while dispatching to "
    
44.           + msg.target.getClass().getName() + " "
    
45.           + msg.callback + " what=" + msg.what);
    
46.      }
    
47. 
    
48.      msg.recycle();
    
49.      }
    
50. }

复制代码

   （1）通过mylooper()获取到了一个Looper对象,并且做了非空判断。

   （2）通过me.mQueue获取该Looper的消息队列

   （3）开始进入无限循环，通过调动queue.next();方法不断的从消息队列中取出Message信息，通过调用msg.target.dispatchMessage(msg)进行消息分发，其实是调用了Handler中的dispatchMessage(Message msg)方法：

   （4）消息分发完之后，调用msg.recycle()回收消息。

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

复制代码

在Looper的构造方法中自动帮我们创建了一个消息队列。

特别注意：

两种情况初始化Looper对象：

       1. 在UI Thread即主线程是系统帮忙创建的Looper，不需要显式的创建Looper对象，直接创建Handler对象即可；因为在主线程ActivityThread的main函数中已经自动调用了创建Looper的方法：Looper.prepareMainLooper();，并在最后调用了Looper.loop()方法进行轮询。

       2.如果在子线程中创建Handler对象，需要创建Looper对象，即调用显式的调用Looper.prepare();

Message：

     进行消息的封装，同时可以指定消息的操作形式

1.     public static Message obtain() {
   
2.      synchronized (sPoolSync) {
   
3.           if (sPool != null) {
   
4.                 Message m = sPool;
   
5.                 sPool = m.next;
   
6.                 m.next = null;
   
7.                 sPoolSize--;
   
8.                 return m;
   
9.           }
   
10.      }
    
11.      return new Message();
    
12.     }

复制代码

当我们调用Message.obtain()方法时获取Message对象时，先判断消息池是否有消息（if (sPool != null)），没有则创建新消息对象，有则从消息池中取出消息，并将取出的消息从池中移除，这样可以避免创建过多的Message对象占用内存。

Message常用的方法：

（1）public int what：变量，用于定义此Message属于何种操作

（2）public Object obj：变量，用于定义此Message传递的信息数据，通过它传递信息

（3）public int arg1：变量，传递一些整型数据时使用

（4）public int arg2：变量，传递一些整型数据时使用

（5）public Handler getTarget()：普通方法，取得操作此消息的Handler对象。

很好的文章