首页 > 代码库 > Handle的原理代码实现

Handle的原理代码实现

 

  本文从源码的角度来分析Handle如何实现的。

 

  首先我们得知道Handler,Looper,Message Queue三者之间的关系

  - Handler封装了消息的发送,也负责接收消。内部会跟Looper关联。

  - Looper 消息封装的载,内部包含了MessageQueue,负责从MessageQueue取出消息,然后交给Handler处理

  - MessageQueue 就是一个消息队列,负责存储消息,有消息过来就存储起来,Looper会循环的从MessageQueue读取消息。(西安尚学堂)软件开发

 

  源码分析

  当我们new一个Handler对象的时候,看看他的构造方法里面做了什么.

  

public Handler(Callback callback, boolean async) {

  if (FIND_POTENTIAL_LEAKS) {

  final Class 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; }

 

  从源码中我们看到他会调用Looper.myLooper方法获取一个Looper对象,然后从Looper对象获取到MessageQueue对象。

 

  Looper myLooper()

  跟进去看看Looper.myLooper()方法做了什么。这是一个静态方法,可以类名.方法名直接调用。

  

public static @Nullable Looper myLooper() {

  return sThreadLocal.get();

  }

 

  这个方法里面就一行代码,从sThreadLocal中获取一个Looper对象,sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。底层是ThreadLocalMap,既然是Map类型那肯定得先set一个Looper对象,然后我们才能从sThreadLocal对象里面get一个Looper对象。

 

  ActivityThread main()

  ActivityThread类是Android APP进程的初始类,它的main函数是这个APP进程的入口。那么这个main函数干了什么事呢。

  

public static final void main(String[] args) {

  ------

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

  -----

  }

 

  在第二行代码调用Looper.prepareMainLooper()方法,第13行调用了Looper.loop()方法。

 

  Looper prepareMainLooper()

  继续跟进Looper.prepareMainLooper()方法,在这个方法中第一行代码调用了内部的prepare方法。prepareMainLooper有点像单例模式中的getInstance方法,只不过getInstance会当时返回一个对象,而prepareMainLooper会新建一个Looper对象,存储在sThreadLocal中。

  

public static void prepareMainLooper() {

  prepare(false);

  synchronized (Looper.class) {

  if (sMainLooper != null) {

  throw new IllegalStateException("The main Looper has already been prepared.");

  }

  sMainLooper = myLooper();

  }

  }

 

  Looper prepare()

  继续跟进prepare方法,看第5行代码,新建了一个Looper对象,调用sThreadLocal.set方法把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 构造方法

  Looper内部包含了MessageQueue,其实就是在new Looper对象的时候就new了一个MessageQueue对象。

 

 private Looper(boolean quitAllowed) {

  mQueue = new MessageQueue(quitAllowed);

  mThread = Thread.currentThread();

  }

 

  Looper loop()

  ActivityThread类main方法中调用了Looper的两个方法,前面我们解释了prepareMainLooper(),现在来看第二个方法loop()。

  

public static void loop() {

  final Looper me = myLooper();//获取Looper对象

  if (me == null) {

  throw new RuntimeException("No Looper; Looper.prepare() wasn‘t called on this thread.");

  }

  final MessageQueue queue = me.mQueue;//从Looper对象获取MessageQueue对象

  // 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 (;;) {//死循环 一直从MessageQueue中遍历消息

  Message msg = queue.next(); // might block

  if (msg == null) {

  return;

  }

  // This must be in a local variable, in case a UI event sets the logger

  final Printer logging = me.mLogging;

  if (logging != null) {

  logging.println(">>>>> Dispatching to " + msg.target + " " +

  msg.callback + ": " + msg.what);

  }

  final long traceTag = me.mTraceTag;

  if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {

  Trace.traceBegin(traceTag, msg.target.getTraceName(msg));

  }

  try {

  //调用handler的dispatchMessage方法,把消息交给handler处理

  msg.target.dispatchMessage(msg);

  } finally {

  if (traceTag != 0) {

  Trace.traceEnd(traceTag);

  }

  }

  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.recycleUnchecked();

  }

  }

 

  这个方法的代码比较多。其实就是一个死循环,一直会从MessageQueue中取消息,如果取到了消息就会执行msg.target.dispatchMessage(msg)这行代码,msg.target就是handler,其实就是调用handler的dispatchMessage方法,然后把从MessageQueue中取到的message传入进去。

 

  Handler dispatchMessage()

  

public void dispatchMessage(Message msg) {

  //如果callback不为空,说明发送消息的时候是post一个Runnable对象

  if (msg.callback != null) {

  handleCallback(msg);

  } else {

  if (mCallback != null) {//这个是用来拦截消息的

  if (mCallback.handleMessage(msg)) {

  return;

  }

  }

  handleMessage(msg);//最终调用我们重写的handleMessage方法

  }

  }

 

  这个方法对消息做最后处理,如果是post类型调用handleCallback方法处理,如果是sendMessage发送的消息。看我们有没有拦截消息,如果没有最终调用handleMessage方法处理。

 

  Handler handleCallback()

  看到这里我们知道为什么post一个Runnable对象,run方法执行的代码在主线程了吧,因为底层根本就没有开启线程,就只是调用了run方法而已。

  

private static void handleCallback(Message message) {

  message.callback.run();

  }

 

  前面我们从创建handler对象开始,以及创建Looper,创建MessageQueue的整个流程,现在来分析下,当我们调用post以及sendMessage方法时,怎么把Message添加到MessageQueue?

 

  Handler post()

  调用了getPostMessage方法,把Runnable传递进去。

  

public final boolean post(Runnable r)

  {

  return sendMessageDelayed(getPostMessage(r), 0);

  }

  Handler getPostMessage()

 

  首先调用Message.obtain()方法,取出一个Message对象,这个方法之前有讲过,然后把Runnable对象赋值了Message对象的callback属性。看到这里我们也明白了dispatchMessage方法为什么要先判断callback是否为空了吧。

  

private static Message getPostMessage(Runnable r) {

  Message m = Message.obtain();

  m.callback = r;

  return m;

  }

 

  Handler enqueueMessage()

  在post方法里面调用了sendMessageDelayed方法,其实最终调用的是enqueueMessage方法,所以我这里就直接看enqueueMessage方法源码。第一行代码就把handler自己赋值给messgae对象的target属性。然后调用MessageQueue的enqueueMessage方法把当前的Messgae添加进去。

  

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

  msg.target = this;

  if (mAsynchronous) {

  msg.setAsynchronous(true);

  }

  return queue.enqueueMessage(msg, uptimeMillis);

  }

 

  小结

  总结:handler负责发送消息,Looper负责接收Handler发送的消息,并直接把消息回传给Handler自己。MessageQueue就是一个存储消息的容器。

Handle的原理代码实现