android handler机制源码解析【异步回调】

流程总结

Looper.prepare()：本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。
Looper.loop()：轮询MessageQueue，回调msg.target.dispatchMessage(msg)方法。
Handler构造方法：得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。
Handler的sendMessage()：会给msg的target赋值为handler自身，然后加入MessageQueue中。
重写handleMessage()：是msg.target.dispatchMessage(msg)最终调用的方法。

Tip：在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。创建handler就不用显示的调用Looper.prepare()和Looper.loop()

观察者模式

Looper

创建一个MessageQueue，轮询MessageQueue

构造方法

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

创建messageQueue

prepare()

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

不能被调用2次，有且只有一个

loop()
- looper方法必须在prepare方法之后运行
- 轮询，无 -> 阻塞，有 -> msg.target.dispatchMessage(msg);
作用
- 绑定当前线程，有且只有一个looper实例和MessageQueue，轮询并通知

handler

消息创建者，异步分发

public Handler() {          this(null, false);  }  public Handler(Callback callback, boolean async) {          if (FIND_POTENTIAL_LEAKS) {              final Class<? extends Handler> klass = getClass();              if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&                      (klass.getModifiers() & Modifier.STATIC) == 0) {                  Log.w(TAG, "The following Handler class should be static or leaks might occur: " +                      klass.getCanonicalName());              }          }            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;      }

mLooper = Looper.myLooper(); 获取looper
mQueue = mLooper.mQueue;获取messagequeue

public final boolean sendMessage(Message msg)   {       return sendMessageDelayed(msg, 0);   }

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {         msg.target = this;         if (mAsynchronous) {             msg.setAsynchronous(true);         }         return queue.enqueueMessage(msg, uptimeMillis);     }

msg.target = this; ＝> msg.target.dispatchMessage(msg); handler发出的消息，最终会保存到消息队列中去

Message

dispathMessage

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

因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理

private Handler mHandler = new Handler()      {          public void handleMessage(android.os.Message msg)          {              switch (msg.what)              {              case value:                                    break;                default:                  break;              }          };      };

public int what：变量，用于定义此Message属于何种操作
public Object obj：变量，用于定义此Message传递的信息数据，通过它传递信息
public int arg1：变量，传递一些整型数据时使用
public int arg2：变量，传递一些整型数据时使用
public Handler getTarget()：普通方法，取得操作此消息的Handler对象。

完成调度信息

{@link #post}, {@link #postAtTime(Runnable, long)},
{@link #postDelayed}, {@link #sendEmptyMessage},
{@link #sendMessage}, {@link #sendMessageAtTime}, and
{@link #sendMessageDelayed} methods. The <em>post</em> versions allow

Handler post

mHandler.post(new Runnable()          {              @Override              public void run()              {                  Log.e("TAG", Thread.currentThread().getName());                  mTxt.setText("yoxi");              }          });

Runnable并没有创建什么线程，而是发送了一条消息

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

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

在getPostMessage中，得到了一个Message对象，然后将我们创建的Runable对象作为callback属性，赋值给了此message.

注：

产生一个Message对象，可以new ，也可以使用Message.obtain()
Message内部维护了一个Message池用于Message的复用，使用Message.obtain()方法避免使用new 重新分配内存。
如果你的message只需要携带简单的int信息，请优先使用Message.arg1和Message.arg2来传递信息，这比用Bundle更省内存
擅用message.what来标识信息，以便用不同方式处理message

如果不为null，则执行callback回调，也就是我们的Runnable对象。

问题

1，使用Handler 是异步的，它会建立新的线程么？不会
2，Handler 是在主线程内么？一般都会在主线程内，但也可以在子线程中创建Handler
3，Handler 的 post 和 sendMessage 方法，使用的是一个队列不安是两个？一个
4，子线程中建立一个 handler, 然后sendMessage 会怎么样？会崩溃
5，子线程建立 handler ,构造的时候舒心入主线程的 Looper ? yes