private Handler mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
		// 處理消息
    }
};
private void sendMessage() {
    // 發(fā)送消息
    Message msg = mHandler.obtainMessage();
	// 填充msg
    mHandler.sendMessage(msg);
}
private void postRunnable() {
	// 告知Handler一段可執(zhí)行的代碼（Runnable）
    mHandler.post(new Runnable() {
        @Override
        public void run() {
            // do something
        }
    });
}

public Handler() {
    this(null, false);
}
public Handler(@NonNull Looper looper) {
    this(looper, null, false);
}
public Handler(@Nullable 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());
        }
    }
	// 獲取當(dāng)前線程對(duì)應(yīng)的Looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread " + Thread.currentThread()
                    + " that has not called Looper.prepare()");
    }
    // 使用Looper中的MessageQueue
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}
@UnsupportedAppUsage
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

public final boolean sendMessage(@NonNull Message msg) {
	 // 沒有延時(shí) 
     return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(@NonNull 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(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    msg.target = this;
    // 記錄一下UID
    msg.workSourceUid = ThreadLocalWorkSource.getUid();
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    // 消息入隊(duì)MessageQueue
    return queue.enqueueMessage(msg, uptimeMillis);
}

public final class Looper {
    private static final String TAG = "Looper";
    // sThreadLocal.get() will return null unless you've called prepare().
    @UnsupportedAppUsage
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    @UnsupportedAppUsage
    private static Looper sMainLooper;  // guarded by Looper.class
    // 省略
    public static Looper getMainLooper() {
       synchronized (Looper.class) {
           return sMainLooper;
       }
   }
}

public class MyThread extends Thread {  
    private Handler mHandler;  
    @Override  
    public void run() {  
        Looper.prepare(); // 準(zhǔn)備Looper  
        mHandler = new Handler() {  
            @Override  
            public void handleMessage(Message msg) {  
                // 處理消息  
                }  
            }  
        };  
        Looper.loop(); // 開始循環(huán)，等待消息  
    }
}

public
class Thread implements Runnable {
   public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
}

MyThread thr = new MyThread();
thr.start();