public class MainActivity extends AppCompatActivity {
 
 public static final int MSG_FINISH = 0X001;
 //創(chuàng)建一個(gè)Handler的匿名內(nèi)部類
 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);
 //啟動(dòng)耗時(shí)操作
 consumeTimeThread(findViewById(R.id.tv));
// handler.post()
 }
 
 //啟動(dòng)一個(gè)耗時(shí)線程
 public void consumeTimeThread(View view) {
 new Thread() {
  public void run() {
  try {
   LogUtils.e("耗時(shí)子線程的Name是--->" + Thread.currentThread().getName());
   //在子線程運(yùn)行
   Thread.sleep(2000);
   //完成后，發(fā)送下載完成消息
   handler.sendEmptyMessage(MSG_FINISH);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  }
 }.start();
 }
}

public class Handler {
	/**
	 * 未實(shí)現(xiàn)的空方法handleMessage（）
	 */
	public void handleMessage(Message msg) {
	}
	/**
	 * 我們通常用于創(chuàng)建Handler的構(gòu)造方法之一
	 */
	public Handler() {
		this(null, false);
	}
	// 構(gòu)造方法的內(nèi)調(diào)用的this(null, false)的具體實(shí)現(xiàn)
	public Handler(Callback callback, boolean async) {
//檢查Handler是否是static的，如果不是的，那么有可能導(dǎo)致內(nèi)存泄露
 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()); 
  } 
 } 
 //重要的組件出現(xiàn)啦！Looper我們先理解成一個(gè)消息隊(duì)列的管理者，用來(lái)從消息隊(duì)列中取消息的，后續(xù)會(huì)詳細(xì)分析
 mLooper = Looper.myLooper(); 
 if (mLooper == null) { 
  //這個(gè)異常很熟悉吧，Handler是必須在有Looper的線程上執(zhí)行，這個(gè)也就是為什么我在HandlerThread中初始化Handler 
  //而沒(méi)有在Thread里面初始化，如果在Thread里面初始化需要先調(diào)用Looper.prepare方法 
  throw new RuntimeException( 
  "Can't create handler inside thread that has not called Looper.prepare()"); 
 } 
 //將mLooper里面的消息隊(duì)列復(fù)制到自身的mQueue,這也就意味著Handler和Looper是公用一個(gè)消息隊(duì)列 
 mQueue = mLooper.mQueue; 
 //回調(diào)函數(shù)默認(rèn)是Null 
 mCallback = null; 
	}

if (mLooper == null) { 
 //這個(gè)異常很熟悉吧，Handler是必須在有Looper的線程上執(zhí)行，這個(gè)也就是為什么我在HandlerThread中初始化Handler 
 //而沒(méi)有在Thread里面初始化，如果在Thread里面初始化需要先調(diào)用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() {
  //子線程中必須先創(chuàng)建Looper
  Looper.prepare();
  
  mHandler =new Handler(){
  @Override
  public void handleMessage(Message msg) {
   super.handleMessage(msg);
   //處理消息
  }
  };
  //啟動(dòng)looper循環(huán)
  Looper.loop();
 }
 }

// 發(fā)送一個(gè)空消息的方法，實(shí)際上添加到MessagerQueue隊(duì)列中
public final boolean sendEmptyMessage(int what) {
	return sendEmptyMessageDelayed(what, 0);
}
// 給上一個(gè)方法調(diào)用
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
	Message msg = Message.obtain();
	msg.what = what;
	return sendMessageDelayed(msg, delayMillis);
}
// 給上一個(gè)方法調(diào)用
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
	if (delayMillis < 0) {
		delayMillis = 0;
	}
	return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
// 給上一個(gè)方法調(diào)用
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);
}
// 最后調(diào)用此方法添加到消息隊(duì)列中
private boolean enqueueMessage(MessageQueue queue, Message msg,
		long uptimeMillis) {
	msg.target = this;// 設(shè)置發(fā)送目標(biāo)對(duì)象是Handler本身
	if (mAsynchronous) {
		msg.setAsynchronous(true);
	}
	return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息隊(duì)列中
}
// 在looper類中的loop（）方法內(nèi)部調(diào)用的方法
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().
	//存放線程的容器類,為確保獲取的線程和原來(lái)的一樣
	static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
	private static Looper sMainLooper; // guarded by Looper.class
	//消息隊(duì)列
	final MessageQueue mQueue;
	final Thread mThread;
	//perpare()方法，用來(lái)初始化一個(gè)Looper對(duì)象
	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調(diào)用的獲取Looper對(duì)象的方法。實(shí)際是在ThreadLocal中獲取。
	public static Looper myLooper() {
		return sThreadLocal.get();
	}
		
	//Looper類的構(gòu)造方法，可以發(fā)現(xiàn)創(chuàng)建Looper的同時(shí)也創(chuàng)建了消息隊(duì)列MessageQueue對(duì)象
	private Looper(boolean quitAllowed) {
		mQueue = new MessageQueue(quitAllowed);
		mRun = true;
		mThread = Thread.currentThread();
	}
		
//這個(gè)方法是給系統(tǒng)調(diào)用的，UI線程通過(guò)調(diào)用這個(gè)線程，從而保證UI線程里有一個(gè)Looper 
//需要注意：如果一個(gè)線程是UI線程，那么myLooper和getMainLooper是同一個(gè)Looper 
 public static final void prepareMainLooper() { 
	prepare(); 
	setMainLooper(myLooper()); 
	if (Process.supportsProcesses()) { 
	 myLooper().mQueue.mQuitAllowed = false; 
	 } 
	} 
	 
//獲得UI線程的Looper,通常我們想Hanlder的handleMessage在UI線程執(zhí)行時(shí)通常會(huì)new Handler(getMainLooper()); 
 public synchronized static final Looper getMainLooper() { 
	 return mMainLooper; 
 } 
		
//looper中最重要的方法loop()，該方法是個(gè)死循環(huán)，會(huì)不斷去消息隊(duì)列MessageQueue中獲取消息，然后調(diào)dispatchMessage(msg)方法去執(zhí)行
 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;
	 //死循環(huán)
	 for (;;) {
		Message msg = queue.next(); // might block
		if (msg == null) {
		// No message indicates that the message queue is quitting.
				return;
		}
//這里其實(shí)就是調(diào)用handler中的方法，而在Handler的源碼中也可以知道dispatchMessage(msg)內(nèi)部調(diào)用的就是handlerMessage()方法
		msg.target.dispatchMessage(msg);
		msg.recycle();
	}
}

//perpare()方法，用來(lái)初始化一個(gè)Looper對(duì)象
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類的構(gòu)造方法，可以發(fā)現(xiàn)創(chuàng)建Looper的同時(shí)也創(chuàng)建了消息隊(duì)列MessageQueue對(duì)象
	private Looper(boolean quitAllowed) {
		mQueue = new MessageQueue(quitAllowed);
		mRun = true;
		mThread = Thread.currentThread();
	}

//handler調(diào)用的獲取Looper對(duì)象的方法。實(shí)際是在ThreadLocal中獲取。
	public static Looper myLooper() {
		return sThreadLocal.get();
	}

//looper中最重要的方法loop()，該方法是個(gè)死循環(huán)，
//會(huì)不斷去消息隊(duì)列MessageQueue中獲取消息，
//然后調(diào)dispatchMessage(msg)方法去執(zhí)行
 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;
	 //死循環(huán)
	 for (;;) {
		Message msg = queue.next(); // might block
		if (msg == null) {
		// No message indicates that the message queue is quitting.
				return;
		}
//這里其實(shí)就是調(diào)用handler中的方法，而在Handler的源碼中也可以知道dispatchMessage(msg)內(nèi)部調(diào)用的就是handlerMessage()方法
		msg.target.dispatchMessage(msg);
		msg.recycle();
	}

// 在looper類中的loop()方法內(nèi)部調(diào)用的方法
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)