//1. 主線程 Handler handler = new MyHandler(); //2. 非主線程 HandlerThread handlerThread = new HandlerThread("handlerThread"); handlerThread.start(); Handler handler = new Handler(handlerThread.getLooper()); //發(fā)送消息 handler.sendMessage(msg); //接收消息 static class MyHandler extends Handler {  //對(duì)于非主線程處理消息需要傳Looper，主線程有默認(rèn)的sMainLooper  public MyHandler(Looper looper) {   super(looper);  }  @Override  public void handleMessage(Message msg) {   super.handleMessage(msg);  } }

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));}public static Looper myLooper() { return sThreadLocal.get();}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; // 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 (;;) {  Message msg = queue.next(); // might block  if (msg == null) {   // No message indicates that the message queue is quitting.   return;  }  // This must be in a local variable, in case a UI event sets the logger  Printer logging = me.mLogging;  if (logging != null) {   logging.println(">>>>> Dispatching to " + msg.target + " " +     msg.callback + ": " + msg.what);  }  msg.target.dispatchMessage(msg);  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(); }}

public void handleMessage(Message msg) {}public void dispatchMessage(Message msg) { if (msg.callback != null) {  handleCallback(msg); } else {  if (mCallback != null) {   if (mCallback.handleMessage(msg)) {    return;   }  }  handleMessage(msg); }}private static void handleCallback(Message message) { message.callback.run();}public final Message obtainMessage(){ return Message.obtain(this);}public final boolean post(Runnable r){ return sendMessageDelayed(getPostMessage(r), 0);}public final boolean sendMessage(Message msg){ return sendMessageDelayed(msg, 0);}private static Message getPostMessage(Runnable r) { Message m = Message.obtain(); m.callback = r; return m;}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; if (mAsynchronous) {  msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis);}public final void removeCallbacksAndMessages(Object token) { mQueue.removeCallbacksAndMessages(this, token);}

boolean enqueueMessage(Message msg, long when) { if (msg.target == null) {  throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) {  throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) {  if (mQuitting) {   IllegalStateException e = new IllegalStateException(     msg.target + " sending message to a Handler on a dead thread");   Log.w("MessageQueue", e.getMessage(), e);   msg.recycle();   return false;  }  msg.markInUse();  msg.when = when;  Message p = mMessages;  boolean needWake;  if (p == null || when == 0 || when < p.when) {   // New head, wake up the event queue if blocked.   msg.next = p;   mMessages = msg;   needWake = mBlocked;  } else {   // Inserted within the middle of the queue. Usually we don't have to wake   // up the event queue unless there is a barrier at the head of the queue   // and the message is the earliest asynchronous message in the queue.   needWake = mBlocked && p.target == null && msg.isAsynchronous();   Message prev;   for (;;) {    prev = p;    p = p.next;    if (p == null || when < p.when) {     break;    }    if (needWake && p.isAsynchronous()) {     needWake = false;    }   }   msg.next = p; // invariant: p == prev.next   prev.next = msg;  }  // We can assume mPtr != 0 because mQuitting is false.  if (needWake) {   nativeWake(mPtr);  } } return true;}Message next() { // Return here if the message loop has already quit and been disposed. // This can happen if the application tries to restart a looper after quit // which is not supported. final long ptr = mPtr; if (ptr == 0) {  return null; } int pendingIdleHandlerCount = -1; // -1 only during first iteration int nextPollTimeoutMillis = 0; for (;;) {  if (nextPollTimeoutMillis != 0) {   Binder.flushPendingCommands();  }  nativePollOnce(ptr, nextPollTimeoutMillis);  synchronized (this) {   // Try to retrieve the next message. Return if found.   final long now = SystemClock.uptimeMillis();   Message prevMsg = null;   Message msg = mMessages;   if (msg != null && msg.target == null) {    // Stalled by a barrier. Find the next asynchronous message in the queue.    do {     prevMsg = msg;     msg = msg.next;    } while (msg != null && !msg.isAsynchronous());   }   if (msg != null) {    if (now < msg.when) {     // Next message is not ready. Set a timeout to wake up when it is ready.     nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);    } else {     // Got a message.     mBlocked = false;     if (prevMsg != null) {      prevMsg.next = msg.next;     } else {      mMessages = msg.next;     }     msg.next = null;     if (false) Log.v("MessageQueue", "Returning message: " + msg);     return msg;    }   } else {    // No more messages.    nextPollTimeoutMillis = -1;   }   // Process the quit message now that all pending messages have been handled.   if (mQuitting) {    dispose();    return null;   }   // If first time idle, then get the number of idlers to run.   // Idle handles only run if the queue is empty or if the first message   // in the queue (possibly a barrier) is due to be handled in the future.   if (pendingIdleHandlerCount < 0     && (mMessages == null || now < mMessages.when)) {    pendingIdleHandlerCount = mIdleHandlers.size();   }   if (pendingIdleHandlerCount <= 0) {    // No idle handlers to run. Loop and wait some more.    mBlocked = true;    continue;   }   if (mPendingIdleHandlers == null) {    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];   }   mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);  }  // Run the idle handlers.  // We only ever reach this code block during the first iteration.  for (int i = 0; i < pendingIdleHandlerCount; i++) {   final IdleHandler idler = mPendingIdleHandlers[i];   mPendingIdleHandlers[i] = null; // release the reference to the handler   boolean keep = false;   try {    keep = idler.queueIdle();   } catch (Throwable t) {    Log.wtf("MessageQueue", "IdleHandler threw exception", t);   }   if (!keep) {    synchronized (this) {     mIdleHandlers.remove(idler);    }   }  }  // Reset the idle handler count to 0 so we do not run them again.  pendingIdleHandlerCount = 0;  // While calling an idle handler, a new message could have been delivered  // so go back and look again for a pending message without waiting.  nextPollTimeoutMillis = 0; }}void removeMessages(Handler h, int what, Object object) { if (h == null) {  return; } synchronized (this) {  Message p = mMessages;  // Remove all messages at front.  while (p != null && p.target == h && p.what == what    && (object == null || p.obj == object)) {   Message n = p.next;   mMessages = n;   p.recycleUnchecked();   p = n;  }  // Remove all messages after front.  while (p != null) {   Message n = p.next;   if (n != null) {    if (n.target == h && n.what == what     && (object == null || n.obj == object)) {     Message nn = n.next;     n.recycleUnchecked();     p.next = nn;     continue;    }   }   p = n;  } }}

/** * Return a new Message instance from the global pool. Allows us to * avoid allocating new objects in many cases. */public static Message obtain() { synchronized (sPoolSync) {  if (sPool != null) {   Message m = sPool;   sPool = m.next;   m.next = null;   m.flags = 0; // clear in-use flag   sPoolSize--;   return m;  } } return new Message();}/** * Return a Message instance to the global pool. * <p> * You MUST NOT touch the Message after calling this function because it has * effectively been freed. It is an error to recycle a message that is currently * enqueued or that is in the process of being delivered to a Handler. * </p> */public void recycle() { if (isInUse()) {  if (gCheckRecycle) {   throw new IllegalStateException("This message cannot be recycled because it "     + "is still in use.");  }  return; } recycleUnchecked();}/** * Recycles a Message that may be in-use. * Used internally by the MessageQueue and Looper when disposing of queued Messages. */void recycleUnchecked() { // Mark the message as in use while it remains in the recycled object pool. // Clear out all other details. flags = FLAG_IN_USE; what = 0; arg1 = 0; arg2 = 0; obj = null; replyTo = null; sendingUid = -1; when = 0; target = null; callback = null; data = null; synchronized (sPoolSync) {  if (sPoolSize < MAX_POOL_SIZE) {   next = sPool;   sPool = this;   sPoolSize++;  } }}

public class HandlerThread extends Thread {int mPriority;int mTid = -1;Looper mLooper;public HandlerThread(String name) { super(name); mPriority = Process.THREAD_PRIORITY_DEFAULT;}@Overridepublic void run() { mTid = Process.myTid(); Looper.prepare(); synchronized (this) {  mLooper = Looper.myLooper();  notifyAll(); } Process.setThreadPriority(mPriority); onLooperPrepared(); Looper.loop(); mTid = -1;}public Looper getLooper() { if (!isAlive()) {  return null; } // If the thread has been started, wait until the looper has been created. synchronized (this) {  while (isAlive() && mLooper == null) {   try {    wait();   } catch (InterruptedException e) {   }  } } return mLooper;}public boolean quit() { Looper looper = getLooper(); if (looper != null) {  looper.quit();  return true; } return false;}}