理解Handler、Looper、MessageQueue、Thread关系？二

最新推荐文章于 2022-10-15 14:58:34 发布

小飞鹤

最新推荐文章于 2022-10-15 14:58:34 发布

阅读量1.2k

点赞数

分类专栏： Android开发详解

Android开发详解专栏收录该内容

129 篇文章 2 订阅

订阅专栏

1.线程间通讯机制

这一篇博文主要是和大家讲解一下线程间通讯机制的内部实现原理，即Handler、Message、MessageQueue、Looper、HandlerThread、AsyncTask类的实现以及之间的关系。如果还没有接触过Handler+Message+Runnable、HandlerThread、AsyncTask的朋友可以先看看基础篇：

【Android开发】线程间通讯机制（基础篇）——Handler、Runnable、HandlerThread、AsyncTask的使用

有时候，如果你能带着问题或者目标去探索新知识的话，这样的学习效率就高很多。所以我们先从最基础的实现方式（Handler+Message+Runnable）说起。

一、Handler+Message+Runnable内部解析

问题：我们在使用Handler类的时候，都知道有sendMessage（Message）等发送消息的功能和post（Runnable）发送任务的功能，然后还有能够处理接受到的Message的功能。这时候我就会提出这样的问题：

1、有发送、接受Message的功能，是不是sendMessage方法是直接调用handleMessage的重写方法里呢？

2、不是有按时间计划发送Message和Runnable吗？如果问题1成立的话，handleMessage可能会同时接受多个Message，但是此方法不是线程安全的（没有synchronized修饰），这样会出现问题了。

解决问题：如果对API有任何疑惑，最根本的方法就是查看源代码。

在看源代码之前，需要了解几个类：

Handler：负责发送Message和Runnable到MessageQueue中，然后依次处理MessageQueue里面的队列。

MessageQueue：消息队列。负责存放一个线程的Message和Runnable的集合。

Message：消息实体类。

Looper：消息循环器。负责把MessageQueue中的Message或者Runnable循环取出来，然后分发到Handler中。

四者的关系：一个线程可以有多个Handler实例，一个线程对应一个Looper，一个Looper也只对应一个MessageQueue，一个MessageQueue对应多个Message和Runnable。所以就形成了一对多的对应关系，一方：线程、Looper、MessageQueue；多方：Handler、Message。同时可以看出另一个一对一关系：一个Message实例对应一个Handler实例。

一个Handler实例都会与一个线程和消息队列捆绑在一起，当实例化Handler的时候，就已经完成这样的工作。源码如下：

Handler类

[java]view plaincopy 
   
 /** 
      * Default constructor associates this handler with the {@link Looper} for the 
      * current thread. 
      * 
      * If this thread does not have a looper, this handler won't be able to receive messages 
      * so an exception is thrown. 
      */  
     public Handler() {  
         this(null, false);  
     }  

[java]view plaincopy 
   
 public Handler(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());  
             }  
         }  
   
         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;  
     }  

可以从mLooper = Looper.myLooper()

mQueue = mLooper.mQueue;看出，实例化Handler就会绑定一个Looper实例，并且一个Looper实例包涵一个MessageQueue实例。

问题来了，为什么说一个线程对应一个Looper实例？我们通过Looper.myLooper()找原因：

Looper类

[java]view plaincopy 
   
 // sThreadLocal.get() will return null unless you've called prepare().  
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();  

[java]view plaincopy 
   
 /** 
      * Return the Looper object associated with the current thread.  Returns 
      * null if the calling thread is not associated with a Looper. 
      */  
     public static Looper myLooper() {  
         return sThreadLocal.get();  
     }  

ThreadLocal类

Implements a thread-local storage, that is, a variable for which each thread has its own value. All threads sharethe sameThreadLocal object, but each sees a different value when accessing it, and changes made by onethread do not affect the other threads. The implementation supportsnull values.

——实现一个线程本地的存储，就是说每个线程都会有自己的内存空间来存放线程自己的值。所有线程都共享一个ThreadLocal对象，但是不同的线程都会对应不同的value，而且单独修改不影响其他线程的value，并且支持null值。

所以说，每个线程都会存放一个独立的Looper实例，通过ThreadLocal.get()方法，就会获得当前线程的Looper的实例。

好了，接下来就要研究一下Handler发送Runnable，究竟怎么发送？

Handler类：

[java]view plaincopy 
   
 public final boolean post(Runnable r)  
     {  
        return  sendMessageDelayed(getPostMessage(r), 0);  
     }  

[java]view plaincopy 
   
 private static Message getPostMessage(Runnable r) {  
         Message m = Message.obtain();  
         m.callback = r;  
         return m;  
     }  

可以看出，其实传入的Runnable对象都是封装到Message类中，看下Message是存放什么信息：

Message类：

[java]view plaincopy 
   
 public final class Message implements Parcelable {    
     public int what;    
     public int arg1;    
     public int arg2;    
     public Object obj;    
     public Messenger replyTo;    
     long when;    
     Bundle data;    
     Handler target;         
     Runnable callback;     
     Message next;    
     private static Object mPoolSync = new Object();    
     private static Message mPool;    
     private static int mPoolSize = 0;    
     private static final int MAX_POOL_SIZE = 10;   

When: 向Handler发送Message生成的时间
Data: 在Bundler 对象上绑定要线程中传递的数据
Next: 当前Message 对一下个Message 的引用
Handler: 处理当前Message 的Handler对象.
mPool: 通过字面理解可能叫他Message池,但是通过分析应该叫有下一个Message引用的Message链更加适合.
其中Message.obtain(),通过源码分析就是获取断掉Message链关系的第一个Message.

对于源码的解读，可以明确两点：

1）Message.obtain()是通过从全局Message pool中读取一个Message，回收的时候也是将该Message 放入到pool中。

2）Message中实现了Parcelable接口

所以接下来看下Handler如何发送Message：

Handler类

[java]view plaincopy 
   
 /** 
     * Enqueue a message into the message queue after all pending messages 
     * before the absolute time (in milliseconds) <var>uptimeMillis</var>. 
     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b> 
     * You will receive it in {@link #handleMessage}, in the thread attached 
     * to this handler. 
     *  
     * @param uptimeMillis The absolute time at which the message should be 
     *         delivered, using the 
     *         {@link android.os.SystemClock#uptimeMillis} time-base. 
     *          
     * @return Returns true if the message was successfully placed in to the  
     *         message queue.  Returns false on failure, usually because the 
     *         looper processing the message queue is exiting.  Note that a 
     *         result of true does not mean the message will be processed -- if 
     *         the looper is quit before the delivery time of the message 
     *         occurs then the message will be dropped. 
     */  
    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);  
    }  

[java]view plaincopy 
   
 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
        msg.target = this;  
        if (mAsynchronous) {  
            msg.setAsynchronous(true);  
        }  
        return queue.enqueueMessage(msg, uptimeMillis);  
    }  

其实无论是按时间计划发送Message或者Runnable，最终是调用了sendMessageAtTime方法，里面核心执行的是enqueueMessage方法，就是调用了MessageQueue中的enqueueMessage方法，就是把消息Message加入到消息队列中。

这时候问题又来了，如果发送消息只是把消息加入到消息队列中，那谁来把消息分发到Handler中呢？

不妨我们看看Looper类：

[java]view plaincopy 
   
 /** 
      * Run the message queue in this thread. Be sure to call 
      * {@link #quit()} to end the loop. 
      */  
     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.<span style="color:#ff0000;"><strong>dispatchMessage</strong></span>(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.recycle();  
         }  
     }  

里面loop方法找到调用Handler的dispatchMessage的方法，我们再看看Handler的dispatchMessage：

[java]view plaincopy 
   
 public void dispatchMessage(Message msg) {  
        if (msg.callback != null) {  
            handleCallback(msg);  
        } else {  
            if (mCallback != null) {  
                if (mCallback.handleMessage(msg)) {  
                    return;  
                }  
            }  
            handleMessage(msg);  
        }  
    }  

dispatchMessage最终是回调了handleMessage。换句话说，Loop的loop()方法就是取得当前线程中的MessageQueue实例，然后不断循环消息分发到对应的Handler实例上。就是只要调用Looper.loop()方法，就可以执行消息分发。

小结：Handler、Message、MessageQueue、Looper的关系原理图：

整个机制实现原理流程：当应用程序运行的时候，会创建一个主线程（UI线程）ActivityThread,这个类里面有个main方法，就是java程序运行的最开始的入口

[java]view plaincopy 
   
 public static void main(String[] args) {  
         SamplingProfilerIntegration.start();  
   
         // CloseGuard defaults to true and can be quite spammy.  We  
         // disable it here, but selectively enable it later (via  
         // StrictMode) on debug builds, but using DropBox, not logs.  
         CloseGuard.setEnabled(false);  
   
         Process.setArgV0("<pre-initialized>");  
   
         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"));  
         }  
   
         <span style="color:#ff0000;">Looper.loop();</span>  
   
         throw new RuntimeException("Main thread loop unexpectedly exited");  
     }  

UI线程就开始就已经调用了loop消息分发，所以当在UI线程实例的Handler对象发送消息或者任务时，会把Message加入到MessageQueue消息队列中，然后分发到Handler的handleMessage方法里。

二、HandlerThread

其实上述就是线程间通讯机制的实现，而HandlerThread和AsyncTask只是对通讯机制进行进一步的封装，要理解也很简单：

HandlerThread类：

[java]view plaincopy 
   
 public class HandlerThread extends Thread {  
     int mPriority;  
     int mTid = -1;  
     Looper mLooper;  
   
     public HandlerThread(String name) {  
         super(name);  
         mPriority = Process.THREAD_PRIORITY_DEFAULT;  
     }  
       
     /** 
      * Constructs a HandlerThread. 
      * @param name 
      * @param priority The priority to run the thread at. The value supplied must be from  
      * {@link android.os.Process} and not from java.lang.Thread. 
      */  
     public HandlerThread(String name, int priority) {  
         super(name);  
         mPriority = priority;  
     }  
       
     /** 
      * Call back method that can be explicitly overridden if needed to execute some 
      * setup before Looper loops. 
      */  
     protected void onLooperPrepared() {  
     }  
   
     public void run() {  
         mTid = Process.myTid();  
         <span style="color:#ff0000;">Looper.prepare();</span>  
         synchronized (this) {  
             mLooper = Looper.myLooper();  
             notifyAll();  
         }  
         Process.setThreadPriority(mPriority);  
         onLooperPrepared();  
         <span style="color:#ff0000;">Looper.loop();</span>  
         mTid = -1;  
     }  
       
     /** 
      * This method returns the Looper associated with this thread. If this thread not been started 
      * or for any reason is isAlive() returns false, this method will return null. If this thread  
      * has been started, this method will block until the looper has been initialized.   
      * @return The looper. 
      */  
     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;  
     }  
       
     /** 
      * Ask the currently running looper to quit.  If the thread has not 
      * been started or has finished (that is if {@link #getLooper} returns 
      * null), then false is returned.  Otherwise the looper is asked to 
      * quit and true is returned. 
      */  
     public boolean quit() {  
         Looper looper = getLooper();  
         if (looper != null) {  
             looper.quit();  
             return true;  
         }  
         return false;  
     }  
       
     /** 
      * Returns the identifier of this thread. See Process.myTid(). 
      */  
     public int getThreadId() {  
         return mTid;  
     }  
 }  

可以看得出,HandlerThread继承了Thread，从run()方法可以看出，HandlerThread要嗲用start()方法，才能实例化HandlerThread的Looper对象，和消息分发功能。

所以使用HandlerThread，必须先运行HandlerThread,才能取出对应的Looper对象，然后使用Handler（Looper）构造方法实例Handler，这样Handler的handleMessage方法就是子线程执行了。

三、AsyncTask

AsyncTask现在是android应用开发最常用的工具类，这个类面向调用者是轻量型的，但是对于系统性能来说是重量型的。这个类很强大，使用者很方便就能使用，只需要在对应的方法实现特定的功能即可。就是因为AsyncTask的强大封装，所以说不是轻量型的，先看下源代码吧：

[java]view plaincopy 
   
 public abstract class AsyncTask<Params, Progress, Result> {  
     private static final String LOG_TAG = "AsyncTask";  
   
     private static final int CORE_POOL_SIZE = 5;  
     private static final int MAXIMUM_POOL_SIZE = 128;  
     private static final int KEEP_ALIVE = 1;  
   
     private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
         private final AtomicInteger mCount = new AtomicInteger(1);  
   
         public Thread newThread(Runnable r) {  
             return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
         }  
     };  
   
     private static final BlockingQueue<Runnable> sPoolWorkQueue =  
             new LinkedBlockingQueue<Runnable>(10);  
   
     /** 
      * An {@link Executor} that can be used to execute tasks in parallel. 
      */  
     public static final Executor THREAD_POOL_EXECUTOR  
             = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
                     TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);  
   
     /** 
      * An {@link Executor} that executes tasks one at a time in serial 
      * order.  This serialization is global to a particular process. 
      */  
     public static final Executor SERIAL_EXECUTOR = new SerialExecutor();  
   
     private static final int MESSAGE_POST_RESULT = 0x1;  
     private static final int MESSAGE_POST_PROGRESS = 0x2;  
   
     private static final InternalHandler sHandler = new InternalHandler();  
   
     private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;  
     private final WorkerRunnable<Params, Result> mWorker;  
     private final FutureTask<Result> mFuture;  
   
     private volatile Status mStatus = Status.PENDING;  
       
     private final AtomicBoolean mCancelled = new AtomicBoolean();  
     private final AtomicBoolean mTaskInvoked = new AtomicBoolean();  
   
     private static class SerialExecutor implements Executor {  
         final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  
         Runnable mActive;  
   
         public synchronized void execute(final Runnable r) {  
             mTasks.offer(new Runnable() {  
                 public void run() {  
                     try {  
                         r.run();  
                     } finally {  
                         scheduleNext();  
                     }  
                 }  
             });  
             if (mActive == null) {  
                 scheduleNext();  
             }  
         }  
   
         protected synchronized void scheduleNext() {  
             if ((mActive = mTasks.poll()) != null) {  
                 THREAD_POOL_EXECUTOR.execute(mActive);  
             }  
         }  
     }  
   
     /** 
      * Indicates the current status of the task. Each status will be set only once 
      * during the lifetime of a task. 
      */  
     public enum Status {  
         /** 
          * Indicates that the task has not been executed yet. 
          */  
         PENDING,  
         /** 
          * Indicates that the task is running. 
          */  
         RUNNING,  
         /** 
          * Indicates that {@link AsyncTask#onPostExecute} has finished. 
          */  
         FINISHED,  
     }  
   
     /** @hide Used to force static handler to be created. */  
     public static void init() {  
         sHandler.getLooper();  
     }  
   
     /** @hide */  
     public static void setDefaultExecutor(Executor exec) {  
         sDefaultExecutor = exec;  
     }  
   
     /** 
      * Creates a new asynchronous task. This constructor must be invoked on the UI thread. 
      */  
     public AsyncTask() {  
         mWorker = new WorkerRunnable<Params, Result>() {  
             public Result call() throws Exception {  
                 mTaskInvoked.set(true);  
   
                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
                 //noinspection unchecked  
                 return postResult(doInBackground(mParams));  
             }  
         };  
   
         mFuture = new FutureTask<Result>(mWorker) {  
             @Override  
             protected void done() {  
                 try {  
                     postResultIfNotInvoked(get());  
                 } catch (InterruptedException e) {  
                     android.util.Log.w(LOG_TAG, e);  
                 } catch (ExecutionException e) {  
                     throw new RuntimeException("An error occured while executing doInBackground()",  
                             e.getCause());  
                 } catch (CancellationException e) {  
                     postResultIfNotInvoked(null);  
                 }  
             }  
         };  
     }  
   
     private void postResultIfNotInvoked(Result result) {  
         final boolean wasTaskInvoked = mTaskInvoked.get();  
         if (!wasTaskInvoked) {  
             postResult(result);  
         }  
     }  
   
     private Result postResult(Result result) {  
         @SuppressWarnings("unchecked")  
         Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
                 new AsyncTaskResult<Result>(this, result));  
         message.sendToTarget();  
         return result;  
     }  
   
       
     public final Status getStatus() {  
         return mStatus;  
     }  
   
       
     protected abstract Result doInBackground(Params... params);  
   
      
     protected void onPreExecute() {  
     }  
   
       
     @SuppressWarnings({"UnusedDeclaration"})  
     protected void onPostExecute(Result result) {  
     }  
   
       
     @SuppressWarnings({"UnusedDeclaration"})  
     protected void onProgressUpdate(Progress... values) {  
     }  
   
      
     @SuppressWarnings({"UnusedParameters"})  
     protected void onCancelled(Result result) {  
         onCancelled();  
     }      
       
       
     protected void onCancelled() {  
     }  
   
       
     public final boolean isCancelled() {  
         return mCancelled.get();  
     }  
   
       
     public final boolean cancel(boolean mayInterruptIfRunning) {  
         mCancelled.set(true);  
         return mFuture.cancel(mayInterruptIfRunning);  
     }  
   
       
     public final Result get() throws InterruptedException, ExecutionException {  
         return mFuture.get();  
     }  
   
       
     public final Result get(long timeout, TimeUnit unit) throws InterruptedException,  
             ExecutionException, TimeoutException {  
         return mFuture.get(timeout, unit);  
     }  
   
       
     public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
         return executeOnExecutor(sDefaultExecutor, params);  
     }  
   
      
     public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,  
             Params... params) {  
         if (mStatus != Status.PENDING) {  
             switch (mStatus) {  
                 case RUNNING:  
                     throw new IllegalStateException("Cannot execute task:"  
                             + " the task is already running.");  
                 case FINISHED:  
                     throw new IllegalStateException("Cannot execute task:"  
                             + " the task has already been executed "  
                             + "(a task can be executed only once)");  
             }  
         }  
   
         mStatus = Status.RUNNING;  
   
         onPreExecute();  
   
         mWorker.mParams = params;  
         exec.execute(mFuture);  
   
         return this;  
     }  
   
       
     public static void execute(Runnable runnable) {  
         sDefaultExecutor.execute(runnable);  
     }  
   
       
     protected final void publishProgress(Progress... values) {  
         if (!isCancelled()) {  
             sHandler.obtainMessage(MESSAGE_POST_PROGRESS,  
                     new AsyncTaskResult<Progress>(this, values)).sendToTarget();  
         }  
     }  
   
     private void finish(Result result) {  
         if (isCancelled()) {  
             onCancelled(result);  
         } else {  
             onPostExecute(result);  
         }  
         mStatus = Status.FINISHED;  
     }  
   
     private static class InternalHandler extends Handler {  
         @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})  
         @Override  
         public void handleMessage(Message msg) {  
             AsyncTaskResult result = (AsyncTaskResult) msg.obj;  
             switch (msg.what) {  
                 case MESSAGE_POST_RESULT:  
                     // There is only one result  
                     result.mTask.finish(result.mData[0]);  
                     break;  
                 case MESSAGE_POST_PROGRESS:  
                     result.mTask.onProgressUpdate(result.mData);  
                     break;  
             }  
         }  
     }  
   
     private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {  
         Params[] mParams;  
     }  
   
     @SuppressWarnings({"RawUseOfParameterizedType"})  
     private static class AsyncTaskResult<Data> {  
         final AsyncTask mTask;  
         final Data[] mData;  
   
         AsyncTaskResult(AsyncTask task, Data... data) {  
             mTask = task;  
             mData = data;  
         }  
     }  
 }  

要理解这个工具类，主要是理解这几个成员对象：

private static final InternalHandler sHandler = new InternalHandler();

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

private final WorkerRunnable<Params, Result> mWorker;

private final FutureTask<Result> mFuture;

分析：sHandler

消息的发送者和处理者

sDefualtExecutor

线程执行者。实际上就是一个线程池。

mWorker

WorkerRunnable实现了Callable接口,就是有返回值的线程任务。

mFuture

FutureTask是对Callable执行的一个管理类，能够获得线程执行返回的结果，和取消执行等操作。我们再深入一下FutureTask，其中的done()方法是回调方法：

[java]view plaincopy 
   
 /** 
   * Removes and signals all waiting threads, invokes done(), and 
   * nulls out callable. 
   */  
  private void finishCompletion() {  
      // assert state > COMPLETING;  
      for (WaitNode q; (q = waiters) != null;) {  
          if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {  
              for (;;) {  
                  Thread t = q.thread;  
                  if (t != null) {  
                      q.thread = null;  
                      LockSupport.unpark(t);  
                  }  
                  WaitNode next = q.next;  
                  if (next == null)  
                      break;  
                  q.next = null; // unlink to help gc  
                  q = next;  
              }  
              break;  
          }  
      }  
   
     <span style="color:#cc0000;"> done();</span>  
   
      callable = null;        // to reduce footprint  
  }  

只要线程移除或者挂起（取消）的时候，就会调用done()方法，然后在AsyncTask类中的mTask实现了done()方法，最后回调onCancelled()方法。

具体的流程原理是这样的：

1、当第一次AsyncTask在UI线程实例化，其实是实例化Handler，同时UI线程的Looper和MessageQueue绑定在sHandler对象中，之后再去实例话AsyncTask不会在初始化Handler，因为sHandler是类变量。

2、当执行execute方法的时候，实际上是调用线程池的execute方法运行线程

3、callable线程执行体就是调用了doInBackground(mParams)方法，然后以返回结果result当参数，又调用postResult(Result result)，实际上就是利用sHandler来发送result到UI线程的MessageQueue中，最后sHandler接受到result后，回调onPostExecute方法。

4、如果主动调用publishProgress(Progress... values)方法，就会利用sHandler把value发送到UI线程的MessageQueue中，然后sHandler接收到value后，回调onProgressUpdate(Progress... values)方法。

注意：sHandler和mDefaultExecutor是类变量

mWorker和mFuture是实例变量

所以，无论进程中生成多少个AysncTask对象，sHandler和mDefaultExecutor都是同一个，只是任务不同而已。

四、总结

由于我放上去的源代码删除了一些注释，如果还不能了解清楚的话，可以自行去源代码上观看。线程间通讯机制的核心就是Handler+Message+Looper+MessageQueue，只要理解这个四者的实现原理，再多的封装好的工具类也难理解。所以，必须记住一点：android应用开发多线程是必不可少的，所以我们必须遵循UI线程模式开发，就是所有耗时不能在UI线程执行，操作UI必须在UI线程中执行。

2.Android开发之消息处理机制（二）——消息循环

* Android开发之消息处理机制（二）——消息循环

* 北京Android俱乐部群：167839253

* Created on: 2011-9-1

* Author: blueeagle

* Email: liujiaxiang@gmail.com

先介绍一下如何在Android应用程序中使用后台线程和UI线程。

创建Android友好的后台线程时，最灵活的方式就是创建Handler子类的一个实例。每个Activity仅需要一个Handler对象，而且不需要手动注册他。

后台线程可以与Handler通讯，Handler将在Activity的UI线程上执行自己所有的工作。这一点非常重要。因为UI的更改，只能发生在Activity的UI线程上。

有两种与Handler通信的方式：消息和Runnable对象。

关于消息：

要向Handler发送一个Message，首先调用obtainMessage()从池中获取Message对象。obtainMessage()对象有许多特点，允许创建空的Message对象或填充了消息标示符和参数的对象。需要的Handler处理过程越复杂，就越需要将数据放在Message中，以帮助Handler区分不同的事件。

然后可以通过消息队列将Message发送给Handler，此时需要使用sendMessage…()系列方法中的一个方法。

sendMessage();立即将消息放在队列中。

sendMessageAtFrontOfQueue();立即将消息放在队列中，并将其放在消息队列的最前面，这样该消息就会具有比所有其他消息更高的优先级。

sendMessageAtTime();在规定的时间将消息放在队列中，这个时间用ms表示，基于系统正常工作时间。（SystemClock.uptimeMillis()）

sendMessageDelayed();在一段延迟之后将消息放在队列中，延迟用ms表示。

要处理这些消息，Handler需要实现handleMessage()，将使用出现在消息队列中的每个消息来调用handleMessage()。此处Handler可以根据需要更新UI。但是，它仍然应该迅速完成此工作，因为在它完成之前，其他UI工作会暂停。

关于Runnable ：

如果不愿意使用Message对象，也可以将Runnable对象传递给Handler，Handler将在ActivityUI线程上运行这些Runnable对象。Handler提供了一组post…()方法来传入Runnable对象供最终处理。

对Android的消息循环机制的理解，可以仿照Windows消息循环的机制进行。

每个Handler都会和一个线程和线程的message queue关联起来，此时你可以传递messages 和 runnable对象到message queue中。后面可以从message queue中拿出该对象并且执行。Handler， Message queue这两个对象之间的交互，就涉及到了Looper这个东西。

关于Handler，Looper，Message Queue三者之间的关系，如下图所示：

Handler有很多构造函数

Handler在无参数的构造方法中调用Looper.myLooper()方法，里面就是从当前线程里面获取一个Looper的同时一并初始化MessageQueue，并且从中得到looper的MessageQueue。可以看出Handler就是Looper和MessageQueue的管理者和调度者。

其中最重要的是sendMessageAtTime方法，当你往Handler中发送Message消息的时候，从代码看出他自己并不去处理Message，而是交给了MessageQueue，由queue.enqueueMessage来处理。

Looper代码中有一个prepare()方法，通过ThreadLocal实现一个线程只有一个Looper。

Handler的消息发送

Handler是一个核心，负责message的创建，获得，处理。Handler的sendMessage()方法最终其实就是调用了queue.enqueueMessage(msg, uptimeMillis);把消息放入message queue中。Looper通过Looper.loop()检测到有消息并将消息广播后，Handler又负责接收到此消息并调用handleMessage进行处理接下来的事情。Message的创建一般都是通过如下代码建立的，把Handler传进去。

public final Message obtainMessage()

{

return Message.obtain(this);

}

这种工作方式如下图所示：

Message在里面是一个链表的结构。在这个方法中，会首先去MessagePool(消息回收站)去找Message，如果有被回收的Message，则会将这个Message取出来进行再利用。如果没有被回收的，这时系统才会真正new一个Message对象出来当然MessagePool不是无限大的，它最多只能保存十条回收的消息，多出来的就直接删除了。

至此，我们看到，一个Message经由Handler创建、发送，MessageQueue的入队，Looper的抽取，又再一次地回到Handler进行处理。而绕的这一圈，也正好帮助我们将同步操作变成了异步操作。

在主线程（UI线程）里，如果创建Handler时不传入Looper对象，那么将直接使用主线程（UI线程）的Looper对象（系统已经帮我们创建了）；在其它线程里，如果创建Handler时不传入Looper对象，那么，这个Handler将不能接收处理消息。在创建Handler之前，为该线程准备好一个Looper（Looper.prepare），然后让这个Looper跑起来（Looper.loop），抽取Message，这样，Handler才能正常工作。

因此，Handler处理消息总是在创建Handler的线程里运行。

下面根据上述理论知识，来举几个例子：

例1：

在UI线程中调用Handler的Post方法。代码如下：

[java]view plaincopy 
   
 /* 
  *  Android开发之消息处理机制（二）——消息循环 
  *  MessageCircle.java   
  *  Created on: 2011-9-2 
  *  Author: blueeagle 
  *  Email: liujiaxiang@gmail.com 
  */  
 package blueeagle.com;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
 import android.os.Handler;  
   
 public class MessageCircle extends Activity {  
     /** Called when the activity is first created. */  
     private Handler myHandler = new Handler();  
     private Runnable myRunnable = new Runnable(){  
         @Override  
         public void run(){  
             try{  
                 Thread.sleep(1000);  
             }  
             catch(InterruptedException e){  
                 e.printStackTrace();  
             }  
             System.out.println("Current Runnable Thread ID:"+Thread.currentThread().getId());  
         }  
     };  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);          
         System.out.println("Current Activity Thread ID:"+Thread.currentThread().getId());  
         myHandler.post(myRunnable);  
     }      
 }  

程序运行结果如下图：

在这个程序中，我们New了一个没有参数的Handler对象myHandler,这个myHandler自动与当前运行程序相关联，也就是说，这个myHandler将与当前运行的线程使用同一个消息队列，并且可以处理该队列中的消息。

在程序代码中，这个myHandler向消息队列中post了一个myRunnable对象。在myRunnable的run方法中，打印当前线程的ID。由结果得知，我们New出来的这个myHandler是把消息或者Runnable对象送到当前的线程中的。这里我们没有调用线程的start()函数，因此也就不会去创建一个新的线程。而是在原有线程的内部，直接调用run()方法。因此输出的ID是相同的。

那么如何创建新的线程呢？在Android开发之消息处理机制（一）中已经知道如何去创建一个新的线程，这里继续举一个例子来进行比较说明。

例2：

首先需要创建一个线程，这个线程可以是自己创建的线程，也可以是HandlerThread，这个线程需要继承于Thread类或者实现Runnable接口。其次需要有一个Handler，这个Handler可以是Handler也可以继承于Handler并且需要有一个有Looper参数的构造函数。然后就可以进行消息的分发执行了。

具体示例代码如下：

[java]view plaincopy 
   
 /* 
  *  Android开发之消息处理机制（二）——消息循环 
  *  MessageCircle.java   
  *  Created on: 2011-9-2 
  *  Author: blueeagle 
  *  Email: liujiaxiang@gmail.com 
  */  
   
 package blueeagle.com;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
 import android.os.Handler;  
 import android.os.HandlerThread;  
 import android.os.Looper;  
 import android.os.Message;  
 import android.widget.TextView;  
   
 public class MessageCircle extends Activity {  
     public class MyOwnThread extends Thread{  
         int sleepSpan = 2000;//休眠时间  
         boolean flag;// 线程执行标志位  
         //----------------------------------//  
         //构造方法,初始化类的主要成员变量  
         public MyOwnThread(){  
             this.flag = true;  
         }  
         //----------------------------------//  
         //方法，线程执行方法  
         @Override  
         public void run(){  
             TextView myTextView = (TextView)findViewById(R.id.mytextview);  
             Looper.prepare();  
             int i = 1;  
             while(flag){  
                 try{  
                     Thread.sleep(sleepSpan);//休眠一段时间  
                     System.out.println("Current MyOwnThread Thread ID: "+Thread.currentThread().getId());  
                     myTextView.setText(i);  
                     i++;  
                 }  
                 catch(Exception e){  
                     e.printStackTrace();//捕获异常并打印  
                 }  
             }                 
             Looper.loop();  
         }  
     }  
     public class MyHandler extends Handler{  
         public MyHandler(){}  
         public MyHandler(Looper looper){  
             super(looper);  
         }  
         @Override  
         public void handleMessage(Message msg){  
             System.out.println("Current MyHandle Thread ID: "+Thread.currentThread().getId());  
             TextView myTextView = (TextView)findViewById(R.id.mytextview);  
             int i = 1;  
             while(true){  
                 try{  
                     Thread.sleep(1000);//休眠一段时间  
                     System.out.println("Current MyHandle Thread ID: "+Thread.currentThread().getId());  
                     myTextView.setText("i");  
                     i++;  
                 }  
                 catch(Exception e){  
                     e.printStackTrace();//捕获异常并打印  
                 }  
             }         
         }  
     }  
     /** Called when the activity is first created. */  
     private MyHandler myHandler = null;  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);          
         System.out.println("Current Activity Thread ID:"+Thread.currentThread().getId());  
         //myHandler.post(myRunnable);  
         HandlerThread myThread = new HandlerThread("myThread");//生成一个HandlerThread对象，使用Looper来处理消息队列。  
         myThread.start();//启动这个线程  
         myHandler = new MyHandler(myThread.getLooper());//将一个线程绑定到myHandler这个对象上。  
         Message msg = myHandler.obtainMessage();//从myHandler这个对象中获取消息  
         msg.sendToTarget();//将msg对象发送给目标的Handler  
           
         //下面制造一个自己的线程  
         MyOwnThread myOwnThread = new MyOwnThread();  
         myOwnThread.start();  
     }      
 }  

关于线程更新UI的方法，在（一）中已经说过。下面利用一个示例将消息循环过程进行展示，进而实现音乐播放，UI线程中更新歌词的例子来说明消息处理机制。例子较简单，没有实现歌词同步等内容。只是为了更深刻的理解线程运行情况。

按照上述理论：代码如下：

[java]view plaincopy 
   
 /* 
  *  Android开发之消息处理机制（二）——消息循环 
  *  MusicPlayer.java   
  *  Created on: 2011-9-3 
  *  Author: blueeagle 
  *  Email: liujiaxiang@gmail.com 
  */  
   
 package blueeagle.com;  
   
 import android.app.Activity;  
 import android.media.MediaPlayer;  
 import android.os.Bundle;  
 import android.os.Handler;  
 import android.os.Looper;  
 import android.os.Message;  
 import android.view.View;  
 import android.view.View.OnClickListener;  
 import android.widget.Button;  
 import android.widget.TextView;  
   
 public class MusicPlayer extends Activity {  
     /** Called when the activity is first created. */  
     Button myButton;  
     TextView myTextView;  
     private UIUpdateThread myUpdateThread = new UIUpdateThread(); //定义一个自己的UI更新的线程类  
     MyHandler mHandler = new MyHandler();//定义自己的一个Handler类  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
         myButton = (Button)findViewById(R.id.myButton);  
         myTextView = (TextView)findViewById(R.id.myTextView);  
         myButton.setOnClickListener(new OnClickListener(){  
             @Override  
             public void onClick(View v) {  
                 // TODO Auto-generated method stub   
                 System.out.println("主线程运行ID："+Thread.currentThread().getId());  
                 new Thread(myUpdateThread).start();//起一个自己定义的线程  
             }             
         });  
     }             
     class MyHandler extends Handler{//继承Handler类时，必须重写handleMessage方法   
         public MyHandler(){  
               
         }  
         public MyHandler(Looper l){  
             super(l);  
             }  
         @Override  
         public void handleMessage(Message msg) {//执行接收到的通知，此时执行的顺序是按照队列进行，即先进先出   
             myTextView.setText(msg.toString());  
             System.out.println("Current Handler Thread ID:"+Thread.currentThread().getId());  
             }   
         }//该线程将会在单独的线程中运行  
       
 class UIUpdateThread implements Runnable {    
 int i=1;  
         public void run() {    
             while (i<11) {    
                 Message msg = mHandler.obtainMessage();  
                 mHandler.sendMessage(msg);  
                 System.out.println("新线程运行ID："+Thread.currentThread().getId());  
                 i++;  
                 try {    
                     Thread.sleep(4000);    
                 } catch (InterruptedException e) {    
                     // TODO Auto-generated catch block     
                     e.printStackTrace();    
                 }    
             }    
         }    
     }  
 }  

关于简单的音乐播放的源码如下：

[java]view plaincopy 
   
 /* 
  *  Android开发之消息处理机制（二）——消息循环 
  *  MusicPlayer.java   
  *  Created on: 2011-9-3 
  *  Author: blueeagle 
  *  Email: liujiaxiang@gmail.com 
  */  
   
 package blueeagle.com;  
   
 import android.app.Activity;  
 import android.media.MediaPlayer;  
 import android.os.Bundle;  
 import android.os.Handler;  
 import android.os.Looper;  
 import android.os.Message;  
 import android.view.View;  
 import android.view.View.OnClickListener;  
 import android.widget.Button;  
 import android.widget.TextView;  
   
 public class MusicPlayer extends Activity {  
     /** Called when the activity is first created. */  
     private MediaPlayer mp;  
     Button myButton;  
     TextView myTextView;  
     private UIUpdateThread myUpdateThread = new UIUpdateThread(); //定义一个自己的UI更新的线程类  
     MyHandler mHandler = new MyHandler();//定义自己的一个Handler类  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
         myButton = (Button)findViewById(R.id.myButton);  
         myTextView = (TextView)findViewById(R.id.myTextView);  
         myButton.setOnClickListener(new OnClickListener(){  
             @Override  
             public void onClick(View v) {  
                 // TODO Auto-generated method stub  
                 mp = MediaPlayer.create(MusicPlayer.this, R.raw.yinweiaiqing);  
                 mp.start();  
                 System.out.println("主线程运行ID："+Thread.currentThread().getId());  
                 new Thread(myUpdateThread).start();  
   
             }             
         });  
     }             
     class MyHandler extends Handler{//继承Handler类时，必须重写handleMessage方法   
         public MyHandler(){  
         }  
         public MyHandler(Looper l){  
             super(l);  
             }  
         @Override  
         public void handleMessage(Message msg) {//执行接收到的通知，此时执行的顺序是按照队列进行，即先进先出   
             myTextView.setText(msg.obj.toString());  
             System.out.println("Current Handler Thread ID:"+Thread.currentThread().getId());  
             }   
         }//该线程将会在单独的线程中运行  
     class UIUpdateThread implements Runnable {    
         int i = 0;  
         String myString[] = {  
                 "这是一个实时播放的线程操作... ...",  
                 "[00:08.79]《因为爱情》",  
                 "[00:19.46]E 给你一张过去的CD",  
                 "[00:28.68]听听那时我们的爱情",  
                 "[00:34.12]有时会突然忘了",  
                 "[00:37.48]我还在爱著你",  
                 "[00:44.98]F 再唱不出那样的歌曲",  
                 "[00:50.48]听到都会红著脸躲避",  
                 "[00:55.83]虽然会经常忘了",  
                 "[00:59.33]我依然爱著你",  
                 "[01:05.49]F 因为爱情 不会轻易悲伤",  
                 "[01:05.49]F 因为爱情 不会轻易悲伤",  
                 "[01:12.09]E 所以一切都是幸福的模样",  
                 "[01:17.24]F 因为爱情 简单的生长",  
                 "[01:22.24]E 依然随时可以为你疯狂",  
                 "[01:27.21]F 因为爱情 怎麼会有沧桑",  
                 "[01:34.30]E 所以我们还是年轻的模样",  
                 "[01:38.90]F 因为爱情 在那个地方",  
                 "[01:44.32]E 依然还有人在那里游荡",  
                 "[01:48.91]E&F 人来人往",  
                 "[02:11.57]F 再唱不出那样的歌曲",  
                 "[02:17.70]听到都会红著脸躲避",  
                 "[02:23.14]虽然会经常忘了",  
                 "[02:26.26]E&F 我依然爱著你",  
                 "[02:32.60]F 因为爱情 不会轻易悲伤",  
                 "[02:39.22]E 所以一切都是幸福的模样",  
                 "[02:44.98]F 因为爱情 简单的生长",  
                 "[02:49.36]E 依然随时可以为你疯狂",  
                 "[02:54.38]F 因为爱情 怎麼会有沧桑",  
                 "[03:00.94]E 所以我们还是年轻的模样",  
                 "[03:06.04]F 因为爱情 在那个地方",  
                 "[03:11.63]E 依然还有人在那里游荡",  
                 "[03:17.04]E&F 人来人往",  
                 "[03:21.98]E 给你一张过去的CD",  
                 "[03:28.58]听听那时我们的爱情",  
                 "[03:33.48]F 有时会突然忘了",  
                 "[03:36.94]E&F 我还在爱著你"};  
         public void run() {    
             while (mp.isPlaying()) {    
                 Message msg = mHandler.obtainMessage(1, 1, 1, myString[i]);  
                 mHandler.sendMessage(msg);  
                 System.out.println("新线程运行ID："+Thread.currentThread().getId());  
                 try {    
                     Thread.sleep(4000);    
                     i++;  
                     if(i == myString.length){  
                         i=myString.length-1;  
                     }   
                 } catch (InterruptedException e) {    
                     // TODO Auto-generated catch block     
                     e.printStackTrace();    
                 }    
             }    
         }    
     }  
 }  

综上，基本了解了Android下的关于线程，消息循环的一些概念，还需要深入了解Looper如何运用在程序中等。

3.Handler、Looper、MessageQueue、Thread实例

一、几个关键概念

1、MessageQueue：是一种数据结构，见名知义，就是一个消息队列，存放消息的地方。每一个线程最多只可以拥有一个MessageQueue数据结构。
创建一个线程的时候，并不会自动创建其MessageQueue。通常使用一个Looper对象对该线程的MessageQueue进行管理。主线程创建时，会创建一
个默认的Looper对象，而Looper对象的创建，将自动创建一个Message Queue。其他非主线程，不会自动创建Looper，要需要的时候，通过调
用prepare函数来实现。

2、Message：消息对象，Message Queue中的存放的对象。一个Message Queue中包含多个Message。
Message实例对象的取得，通常使用Message类里的静态方法obtain(),该方法有多个重载版本可供选择；它的创建并不一定是直接创建一个新的实例，
而是先从Message Pool(消息池)中看有没有可用的Message实例，存在则直接取出返回这个实例。如果Message Pool中没有可用的Message实例，
则才用给定的参数创建一个Message对象。调用removeMessages()时，将Message从Message Queue中删除，同时放入到Message Pool中。除了上面这
种方式，也可以通过Handler对象的obtainMessage()获取一个Message实例。

3、Looper：
是MessageQueue的管理者。每一个MessageQueue都不能脱离Looper而存在，Looper对象的创建是通过prepare函数来实现的。同时每一个Looper对象
和一个线程关联。通过调用Looper.myLooper()可以获得当前线程的Looper对象
创建一个Looper对象时，会同时创建一个MessageQueue对象。除了主线程有默认的Looper，其他线程默认是没有MessageQueue对象的，所以，不能
接受Message。如需要接受，自己定义一个Looper对象(通过prepare函数),这样该线程就有了自己的Looper对象和MessageQueue数据结构了。
Looper从MessageQueue中取出Message然后，交由Handler的handleMessage进行处理。处理完成后，调用Message.recycle()将其放入Message Pool中。

4、Handler：
消息的处理者，handler负责将需要传递的信息封装成Message，通过调用handler对象的obtainMessage()来实现；
将消息传递给Looper，这是通过handler对象的sendMessage()来实现的。继而由Looper将Message放入MessageQueue中。
当Looper对象看到MessageQueue中含有Message，就将其广播出去。该handler对象收到该消息后，调用相应的handler对象的handleMessage()方法
对其进行处理。

二、线程之间的消息如何进行传递

1、主线程给自己发送Message

package test.message;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {

private Button btnTest;
private TextView textView;

private Handler handler;

@Override
public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);

      btnTest = (Button)this.findViewById(R.id.btn_01);
      textView = (TextView)this.findViewById(R.id.view_01);

      btnTest.setOnClickListener(new View.OnClickListener() {

         @Override
         public void onClick(View arg0) {

            Looper looper = Looper.getMainLooper(); //主线程的Looper对象
            //这里以主线程的Looper对象创建了handler，
            //所以，这个handler发送的Message会被传递给主线程的MessageQueue。
            handler = new MyHandler(looper);
            handler.removeMessages(0);
            //构建Message对象
            //第一个参数：是自己指定的message代号，方便在handler选择性地接收
            //第二三个参数没有什么意义
            //第四个参数需要封装的对象
            Message msg = handler.obtainMessage(1,1,1,"主线程发消息了");

            handler.sendMessage(msg); //发送消息

         }
      });
}

class MyHandler extends Handler{

      public MyHandler(Looper looper){
         super(looper);
      }

      public void handleMessage(Message msg){
         super.handleMessage(msg);
         textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);
      }
}
}

2、其他线程给主线程发送Message

package test.message;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {

private Button btnTest;
private TextView textView;

private Handler handler;

@Override
public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);

      btnTest = (Button)this.findViewById(R.id.btn_01);
      textView = (TextView)this.findViewById(R.id.view_01);

      btnTest.setOnClickListener(new View.OnClickListener() {

         @Override
         public void onClick(View arg0) {

            //可以看出这里启动了一个线程来操作消息的封装和发送的工作
            //这样原来主线程的发送就变成了其他线程的发送，简单吧？呵呵
            new MyThread().start();
         }
      });
}

class MyHandler extends Handler{

      public MyHandler(Looper looper){
         super(looper);
      }

      public void handleMessage(Message msg){
         super.handleMessage(msg);
         textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);
      }
}

//加了一个线程类
class MyThread extends Thread{

      public void run(){
         Looper looper = Looper.getMainLooper(); //主线程的Looper对象
         //这里以主线程的Looper对象创建了handler，
         //所以，这个handler发送的Message会被传递给主线程的MessageQueue。
         handler = new MyHandler(looper);

         //构建Message对象
         //第一个参数：是自己指定的message代号，方便在handler选择性地接收
         //第二三个参数没有什么意义
         //第四个参数需要封装的对象
         Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");

         handler.sendMessage(msg); //发送消息
      }
}
}

3、主线程给其他线程发送Message

package test.message;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {

private Button btnTest;
private TextView textView;

private Handler handler;

@Override
public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);

      btnTest = (Button)this.findViewById(R.id.btn_01);
      textView = (TextView)this.findViewById(R.id.view_01);


      //启动线程
      new MyThread().start();

      btnTest.setOnClickListener(new View.OnClickListener() {

         @Override
         public void onClick(View arg0) {
            //这里handler的实例化在线程中
            //线程启动的时候就已经实例化了
            Message msg = handler.obtainMessage(1,1,1,"主线程发送的消息");
            handler.sendMessage(msg);
         }
      });
}

class MyHandler extends Handler{

      public MyHandler(Looper looper){
         super(looper);
      }

      public void handleMessage(Message msg){
         super.handleMessage(msg);
         textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);
      }
}

class MyThread extends Thread{

      public void run(){
         Looper.prepare(); //创建该线程的Looper对象，用于接收消息

         //注意了：这里的handler是定义在主线程中的哦，呵呵，
         //前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
         //现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象
         //还不存在呢。现在可以实例化了
         //这里Looper.myLooper()获得的就是该线程的Looper对象了
         handler = new ThreadHandler(Looper.myLooper());

         //这个方法，有疑惑吗？
         //其实就是一个循环，循环从MessageQueue中取消息。
         //不经常去看看，你怎么知道你有新消息呢？？？
         Looper.loop();

      }

      //定义线程类中的消息处理类
      class ThreadHandler extends Handler{

         public ThreadHandler(Looper looper){
            super(looper);
         }

         public void handleMessage(Message msg){
            //这里对该线程中的MessageQueue中的Message进行处理
            //这里我们再返回给主线程一个消息
            handler = new MyHandler(Looper.getMainLooper());

            Message msg2 = handler.obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);

            handler.sendMessage(msg2);
         }
      }
}
}

4、其他线程给自己发送Message

package test.message;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {

private Button btnTest;
private TextView textView;

private Handler handler;

@Override
public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);

      btnTest = (Button)this.findViewById(R.id.btn_01);
      textView = (TextView)this.findViewById(R.id.view_01);


      btnTest.setOnClickListener(new View.OnClickListener() {

         @Override
         public void onClick(View arg0) {
            //启动线程
            new MyThread().start();
         }
      });
}

class MyHandler extends Handler{

      public MyHandler(Looper looper){
         super(looper);
      }

      public void handleMessage(Message msg){
         super.handleMessage(msg);
         textView.setText((String)msg.obj);
      }
}

class MyThread extends Thread{

      public void run(){
         Looper.prepare(); //创建该线程的Looper对象
         //这里Looper.myLooper()获得的就是该线程的Looper对象了
         handler = new ThreadHandler(Looper.myLooper());
         Message msg = handler.obtainMessage(1,1,1,"我自己");
         handler.sendMessage(msg);

         Looper.loop();

      }

      //定义线程类中的消息处理类
      class ThreadHandler extends Handler{

         public ThreadHandler(Looper looper){
            super(looper);
         }

         public void handleMessage(Message msg){
            //这里对该线程中的MessageQueue中的Message进行处理
            //这里我们再返回给主线程一个消息
            //加入判断看看是不是该线程自己发的信息
            if(msg.what == 1 && msg.obj.equals("我自己")){

                  handler = new MyHandler(Looper.getMainLooper());

                  Message msg2 = handler.obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");

                  handler.sendMessage(msg2);
            }

         }
      }
}
}

附注：
上面四个例子的布局文件是同一个文件main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView  android:id="@+id/view_01"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>

<Button android:id="@+id/btn_01"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="测试消息" />
</LinearLayout>