深入Android Handler,MessageQueue与Looper关系

public class MainActivity extends AppCompatActivity {
 public static final int MSG_FINISH = 0X001;
 //创建一个Handler的匿名内部类
 private Handler handler = new Handler() {
 @Override
 public void handleMessage(Message msg) {
  switch (msg.what) {
  case MSG_FINISH:
   LogUtils.e("handler所在的线程id是-->" + Thread.currentThread().getName());
   break;
  }
 }
 };
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 //启动耗时操作
 consumeTimeThread(findViewById(R.id.tv));
// handler.post()
 }
 //启动一个耗时线程
 public void consumeTimeThread(View view) {
 new Thread() {
  public void run() {
  try {
   LogUtils.e("耗时子线程的Name是--->" + Thread.currentThread().getName());
   //在子线程运行
   Thread.sleep(2000);
   //完成后，发送下载完成消息
   handler.sendEmptyMessage(MSG_FINISH);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  }
 }.start();
 }
}

public class Handler {
	/**
	 * 未实现的空方法handleMessage（）
	 */
	public void handleMessage(Message msg) {
	}
	/**
	 * 我们通常用于创建Handler的构造方法之一
	 */
	public Handler() {
		this(null, false);
	}
	// 构造方法的内调用的this(null, false)的具体实现
	public Handler(Callback callback, boolean async) {
//检查Handler是否是static的，如果不是的，那么有可能导致内存泄露
 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()); 
  } 
 } 
 //重要的组件出现啦！Looper我们先理解成一个消息队列的管理者，用来从消息队列中取消息的，后续会详细分析
 mLooper = Looper.myLooper(); 
 if (mLooper == null) { 
  //这个异常很熟悉吧，Handler是必须在有Looper的线程上执行，这个也就是为什么我在HandlerThread中初始化Handler 
  //而没有在Thread里面初始化，如果在Thread里面初始化需要先调用Looper.prepare方法 
  throw new RuntimeException( 
  "Can't create handler inside thread that has not called Looper.prepare()"); 
 } 
 //将mLooper里面的消息队列复制到自身的mQueue,这也就意味着Handler和Looper是公用一个消息队列 
 mQueue = mLooper.mQueue; 
 //回调函数默认是Null 
 mCallback = null; 
	}

if (mLooper == null) { 
 //这个异常很熟悉吧，Handler是必须在有Looper的线程上执行，这个也就是为什么我在HandlerThread中初始化Handler 
 //而没有在Thread里面初始化，如果在Thread里面初始化需要先调用Looper.prepare方法 
 throw new RuntimeException( 
 "Can't create handler inside thread that has not called Looper.prepare()"); 
 } 

class childThread extends Thread{
 public Handler mHandler;
 @Override
 public void run() {
  //子线程中必须先创建Looper
  Looper.prepare();
  mHandler =new Handler(){
  @Override
  public void handleMessage(Message msg) {
   super.handleMessage(msg);
   //处理消息
  }
  };
  //启动looper循环
  Looper.loop();
 }
 }

// 发送一个空消息的方法，实际上添加到MessagerQueue队列中
public final boolean sendEmptyMessage(int what) {
	return sendEmptyMessageDelayed(what, 0);
}
// 给上一个方法调用
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
	Message msg = Message.obtain();
	msg.what = what;
	return sendMessageDelayed(msg, delayMillis);
}
// 给上一个方法调用
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
	if (delayMillis < 0) {
		delayMillis = 0;
	}
	return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
// 给上一个方法调用
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
	MessageQueue queue = mQueue;
	if (queue == null) {
		RuntimeException e = new RuntimeException(this
				+ " sendMessageAtTime() called with no mQueue");
		Log.w("Looper", e.getMessage(), e);
		return false;
	}
	return enqueueMessage(queue, msg, uptimeMillis);
}
// 最后调用此方法添加到消息队列中
private boolean enqueueMessage(MessageQueue queue, Message msg,
		long uptimeMillis) {
	msg.target = this;// 设置发送目标对象是Handler本身
	if (mAsynchronous) {
		msg.setAsynchronous(true);
	}
	return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息队列中
}
// 在looper类中的loop（）方法内部调用的方法
public void dispatchMessage(Message msg) {
	if (msg.callback != null) {
		handleCallback(msg);
	} else {
		if (mCallback != null) {
			if (mCallback.handleMessage(msg)) {
				return;
			}
		}
		handleMessage(msg);
	}
}

public final class Looper {
	// sThreadLocal.get() will return null unless you've called prepare().
	//存放线程的容器类,为确保获取的线程和原来的一样
	static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
	private static Looper sMainLooper; // guarded by Looper.class
	//消息队列
	final MessageQueue mQueue;
	final Thread mThread;
	//perpare()方法，用来初始化一个Looper对象
	public static void prepare() {
		prepare(true);
	}
	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));
	}
	//handler调用的获取Looper对象的方法。实际是在ThreadLocal中获取。
	public static Looper myLooper() {
		return sThreadLocal.get();
	}
	//Looper类的构造方法，可以发现创建Looper的同时也创建了消息队列MessageQueue对象
	private Looper(boolean quitAllowed) {
		mQueue = new MessageQueue(quitAllowed);
		mRun = true;
		mThread = Thread.currentThread();
	}
//这个方法是给系统调用的，UI线程通过调用这个线程，从而保证UI线程里有一个Looper 
//需要注意：如果一个线程是UI线程，那么myLooper和getMainLooper是同一个Looper 
 public static final void prepareMainLooper() { 
	prepare(); 
	setMainLooper(myLooper()); 
	if (Process.supportsProcesses()) { 
	 myLooper().mQueue.mQuitAllowed = false; 
	 } 
	} 
//获得UI线程的Looper,通常我们想Hanlder的handleMessage在UI线程执行时通常会new Handler(getMainLooper()); 
 public synchronized static final Looper getMainLooper() { 
	 return mMainLooper; 
 } 
//looper中最重要的方法loop()，该方法是个死循环，会不断去消息队列MessageQueue中获取消息，然后调dispatchMessage(msg)方法去执行
 public static void loop() {
	final Looper me = myLooper();
	if (me == null) {
		throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
		}
	 final MessageQueue queue = me.mQueue;
	 //死循环
	 for (;;) {
		Message msg = queue.next(); // might block
		if (msg == null) {
		// No message indicates that the message queue is quitting.
				return;
		}
//这里其实就是调用handler中的方法，而在Handler的源码中也可以知道dispatchMessage(msg)内部调用的就是handlerMessage()方法
		msg.target.dispatchMessage(msg);
		msg.recycle();
	}
}

//perpare()方法，用来初始化一个Looper对象
public static void prepare() {
	prepare(true);
}
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对象
	private Looper(boolean quitAllowed) {
		mQueue = new MessageQueue(quitAllowed);
		mRun = true;
		mThread = Thread.currentThread();
	}

//handler调用的获取Looper对象的方法。实际是在ThreadLocal中获取。
	public static Looper myLooper() {
		return sThreadLocal.get();
	}

//looper中最重要的方法loop()，该方法是个死循环，
//会不断去消息队列MessageQueue中获取消息，
//然后调dispatchMessage(msg)方法去执行
 public static void loop() {
	final Looper me = myLooper();
	if (me == null) {
		throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
		}
	 final MessageQueue queue = me.mQueue;
	 //死循环
	 for (;;) {
		Message msg = queue.next(); // might block
		if (msg == null) {
		// No message indicates that the message queue is quitting.
				return;
		}
//这里其实就是调用handler中的方法，而在Handler的源码中也可以知道dispatchMessage(msg)内部调用的就是handlerMessage()方法
		msg.target.dispatchMessage(msg);
		msg.recycle();
	}

// 在looper类中的loop()方法内部调用的方法
public void dispatchMessage(Message msg) {
	if (msg.callback != null) {
		handleCallback(msg);
	} else {
		if (mCallback != null) {
			if (mCallback.handleMessage(msg)) {
				return;
			}
		}
		handleMessage(msg);
	}

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

private static void handleCallback(Message message) {
 message.callback.run();
 }

/**
 * Callback interface you can use when instantiating a Handler to avoid
 * having to implement your own subclass of Handler.
 *
 * @param msg A {@link android.os.Message Message} object
 * @return True if no further handling is desired
 */
 public interface Callback {
 public boolean handleMessage(Message msg);
 }

Handler handler =new Handler(callback)