ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(  
    int corePoolSize,  
    int maximumPoolSize,  
    long keepAliveTime,  
    TimeUnit unit,  
    BlockingQueue<Runnable> workQueue  
);

public class PriorityThreadFactory implements ThreadFactory {  

    private final int mThreadPriority;  

    public PriorityThreadFactory(int threadPriority) {  
        mThreadPriority = threadPriority;  
    }  

    @Override  
    public Thread newThread(final Runnable runnable) {  
        Runnable wrapperRunnable = new Runnable() {  
            @Override  
            public void run() {  
                try {  
                    Process.setThreadPriority(mThreadPriority);  
                } catch (Throwable t) {  

                }  
                runnable.run();  
            }  
        };  
        return new Thread(wrapperRunnable);  
    }  

}

public class MainThreadExecutor implements Executor {  

    private final Handler handler = new Handler(Looper.getMainLooper());  

    @Override  
    public void execute(Runnable runnable) {  
        handler.post(runnable);  
    }  
}

/*  
* Singleton class for default executor supplier  
*/  
public class DefaultExecutorSupplier{  
    /*  
    * Number of cores to decide the number of threads  
    */  
    public static final int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();  

    /*  
    * thread pool executor for background tasks  
    */  
    private final ThreadPoolExecutor mForBackgroundTasks;  
    /*  
    * thread pool executor for light weight background tasks  
    */  
    private final ThreadPoolExecutor mForLightWeightBackgroundTasks;  
    /*  
    * thread pool executor for main thread tasks  
    */  
    private final Executor mMainThreadExecutor;  
    /*  
    * an instance of DefaultExecutorSupplier  
    */  
    private static DefaultExecutorSupplier sInstance;  

    /*  
    * returns the instance of DefaultExecutorSupplier  
    */  
    public static DefaultExecutorSupplier getInstance() {  
       if (sInstance == null) {  
         synchronized(DefaultExecutorSupplier.class){                                                                    
             sInstance = new DefaultExecutorSupplier();        
        }  
        return sInstance;  
    }  

    /*  
    * constructor for  DefaultExecutorSupplier  
    */   
    private DefaultExecutorSupplier() {  

        // setting the thread factory  
        ThreadFactory backgroundPriorityThreadFactory = new   
                PriorityThreadFactory(Process.THREAD_PRIORITY_BACKGROUND);  

        // setting the thread pool executor for mForBackgroundTasks;  
        mForBackgroundTasks = new ThreadPoolExecutor(  
                NUMBER_OF_CORES * 2,  
                NUMBER_OF_CORES * 2,  
                60L,  
                TimeUnit.SECONDS,  
                new LinkedBlockingQueue<Runnable>(),  
                backgroundPriorityThreadFactory  
        );  

        // setting the thread pool executor for mForLightWeightBackgroundTasks;  
        mForLightWeightBackgroundTasks = new ThreadPoolExecutor(  
                NUMBER_OF_CORES * 2,  
                NUMBER_OF_CORES * 2,  
                60L,  
                TimeUnit.SECONDS,  
                new LinkedBlockingQueue<Runnable>(),  
                backgroundPriorityThreadFactory  
        );  

        // setting the thread pool executor for mMainThreadExecutor;  
        mMainThreadExecutor = new MainThreadExecutor();  
    }  

    /*  
    * returns the thread pool executor for background task  
    */  
    public ThreadPoolExecutor forBackgroundTasks() {  
        return mForBackgroundTasks;  
    }  

    /*  
    * returns the thread pool executor for light weight background task  
    */  
    public ThreadPoolExecutor forLightWeightBackgroundTasks() {  
        return mForLightWeightBackgroundTasks;  
    }  

    /*  
    * returns the thread pool executor for main thread task  
    */  
    public Executor forMainThreadTasks() {  
        return mMainThreadExecutor;  
    }  
}

/*  
* Using it for Background Tasks  
*/  
public void doSomeBackgroundWork(){  
  DefaultExecutorSupplier.getInstance().forBackgroundTasks()  
    .execute(new Runnable() {  
    @Override  
    public void run() {  
       // do some background work here.  
    }  
  });  
}  

/*  
* Using it for Light-Weight Background Tasks  
*/  
public void doSomeLightWeightBackgroundWork(){  
  DefaultExecutorSupplier.getInstance().forLightWeightBackgroundTasks()  
    .execute(new Runnable() {  
    @Override  
    public void run() {  
       // do some light-weight background work here.  
    }  
  });  
}  

/*  
* Using it for MainThread Tasks  
*/  
public void doSomeMainThreadWork(){  
  DefaultExecutorSupplier.getInstance().forMainThreadTasks()  
    .execute(new Runnable() {  
    @Override  
    public void run() {  
       // do some Main Thread work here.  
    }  
  });  
}

/*  
* Get the future of the task by submitting it to the pool  
*/  
Future future = DefaultExecutorSupplier.getInstance().forBackgroundTasks()  
    .submit(new Runnable() {  
    @Override  
    public void run() {  
      // do some background work here.  
    }  
});  

/*  
* cancelling the task  
*/  
future.cancel(true);

/**  
 * Priority levels  
 */  
public enum Priority {  
    /**  
     * NOTE: DO NOT CHANGE ORDERING OF THOSE CONSTANTS UNDER ANY CIRCUMSTANCES.  
     * Doing so will make ordering incorrect.  
     */  

    /**  
     * Lowest priority level. Used for prefetches of data.  
     */  
    LOW,  

    /**  
     * Medium priority level. Used for warming of data that might soon get visible.  
     */  
    MEDIUM,  

    /**  
     * Highest priority level. Used for data that are currently visible on screen.  
     */  
    HIGH,  

    /**  
     * Highest priority level. Used for data that are required instantly(mainly for emergency).  
     */  
    IMMEDIATE;  

}

public class PriorityRunnable implements Runnable {  

    private final Priority priority;  

    public PriorityRunnable(Priority priority) {  
        this.priority = priority;  
    }  

    @Override  
    public void run() {  
      // nothing to do here.  
    }  

    public Priority getPriority() {  
        return priority;  
    }  

}

public class PriorityThreadPoolExecutor extends ThreadPoolExecutor {  

   public PriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,  
         TimeUnit unit, ThreadFactory threadFactory) {  
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit,new PriorityBlockingQueue<Runnable>(), threadFactory);  
    }  

    @Override  
    public Future<?> submit(Runnable task) {  
        PriorityFutureTask futureTask = new PriorityFutureTask((PriorityRunnable) task);  
        execute(futureTask);  
        return futureTask;  
    }  

    private static final class PriorityFutureTask extends FutureTask<PriorityRunnable>  
            implements Comparable<PriorityFutureTask> {  
        private final PriorityRunnable priorityRunnable;  

        public PriorityFutureTask(PriorityRunnable priorityRunnable) {  
            super(priorityRunnable, null);  
            this.priorityRunnable = priorityRunnable;  
        }  

        /*  
         * compareTo() method is defined in interface java.lang.Comparable and it is used  
         * to implement natural sorting on java classes. natural sorting means the the sort   
         * order which naturally applies on object e.g. lexical order for String, numeric   
         * order for Integer or Sorting employee by there ID etc. most of the java core   
         * classes including String and Integer implements CompareTo() method and provide  
         * natural sorting.  
         */  
        @Override  
        public int compareTo(PriorityFutureTask other) {  
            Priority p1 = priorityRunnable.getPriority();  
            Priority p2 = other.priorityRunnable.getPriority();  
            return p2.ordinal() - p1.ordinal();  
        }  
    }  
}

public class DefaultExecutorSupplier{  

private final PriorityThreadPoolExecutor mForBackgroundTasks;  

private DefaultExecutorSupplier() {  

        mForBackgroundTasks = new PriorityThreadPoolExecutor(  
                NUMBER_OF_CORES * 2,  
                NUMBER_OF_CORES * 2,  
                60L,  
                TimeUnit.SECONDS,  
                backgroundPriorityThreadFactory  
        );  

    }  
}

/*  
* do some task at high priority  
*/  
public void doSomeTaskAtHighPriority(){  
  DefaultExecutorSupplier.getInstance().forBackgroundTasks()  
    .submit(new PriorityRunnable(Priority.HIGH) {  
    @Override  
    public void run() {  
      // do some background work here at high priority.  
    }  
});  
}

public void onClick(View v) {
    new Thread(new Runnable() {
        public void run() {
            Bitmap b = loadImageFromNetwork("http://example.com/image.png");
            mImageView.setImageBitmap(b);
        }
    }).start();
}

例如，您可以通过使用 View.post(Runnable) 方法修复上述代码：
public void onClick(View v) {
    new Thread(new Runnable() {
        public void run() {
            final Bitmap bitmap =
                    loadImageFromNetwork("http://example.com/image.png");
            mImageView.post(new Runnable() {
                public void run() {
                    mImageView.setImageBitmap(bitmap);
                }
            });
        }
    }).start();
}

public void onClick(View v) {
    new DownloadImageTask().execute("http://example.com/image.png");
}
private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
    /** The system calls this to perform work in a worker thread and
      * delivers it the parameters given to AsyncTask.execute() */
    protected Bitmap doInBackground(String... urls) {
        return loadImageFromNetwork(urls[0]);
    }
    /** The system calls this to perform work in the UI thread and delivers
      * the result from doInBackground() */
    protected void onPostExecute(Bitmap result) {
        mImageView.setImageBitmap(result);
    }
}

public Handler() {  

    mLooper = Looper.myLooper();  

    //当前线程的Looper，在Activity创建时，UI线程已经创建了Looper对象  
    //在Handler中机制中Looper是最为核心的，它一直处于循环读MessageQueue，有   
    //要处理的Message就将Message发送给当前的Handler实例来处理


    if (mLooper == null) {  
        throw new RuntimeException(  
            "Can’t create handler inside thread that has not called Looper.prepare()"); 
    }  

    //从以上可以看出，一个Handler实例必须关联一个Looper对象，否则出错

    mQueue = mLooper.mQueue;  

//Handler的MessageQueue，它是FIFO的吗？不是！我感觉应该是按时间先后排列    
//的！Message与MessageQueue到底是啥关系？感兴趣可以研究一下源码！

     mCallback = null;  
}

private static final class Worker implements Runnable  
 {  
  private static final Object mLock = new Object() ;  
  private Looper mLooper ;  
  public Worker(String name)  
  {  
   final Thread thread = new Thread(null,this,name) ;  
   thread.setPriority(Thread.MIN_PRIORITY) ;  
   thread.start() ;  
   synchronized(mLock)  
   {  
    while(mLooper == null)  
    {  
     try   
     {  
      mLock.wait() ;  
     }   
     catch (InterruptedException e)   
     {  
      e.printStackTrace();  
     }  
    }  
   }  
  }  
  @Override  
  public void run() {  
   synchronized(mLock)  
   {      
    //该方法只能执行一次,一个Thread只能关联一个Looper  
       Looper.prepare() ;  
       mLooper = Looper.myLooper() ;  
       mLock.notifyAll() ;  
    }  
     Looper.loop() ;  
  }  
  public Looper getLooper()  
  {  
   return mLooper ;  
  }  
  public void quit()  
  {  
     mLooper.quit() ;  
  }  
 }

private final class MyHandler extends Handler  
 {  
  private long id ;  
  public MyHandler(Looper looper)  
  {  
   super(looper) ;  
  }  
  @Override  
  public void handleMessage(Message msg) {  
   switch(msg.what)  
   {  
   case 100 :  
    mTv.setText("" + id) ;  
    break ;  
   }  
  }  
 }  
---------在Activity中创建Handler  
this.mWorker = new Worker("workerThread") ;  
this.mMyHandler = new MyHandler(this.mWorker.getLooper()) ;  
---------创建Message  
final Message msg = this.mMyHandler.obtainMessage(100);  
msg.put("test" , "test") ;  
msg.sendToTarget() ;

public final Message obtainMessage(int what)  
    {  
        return Message.obtain(this, what);  
    }  
public static Message obtain(Handler h, int what) {  
        Message m = obtain();  
        m.target = h;//可以看出message关联了当前的Handler  
        m.what = what;  
        return m;  
    }

我们平时使用Handler主要是用来处理多线程的异步交互问题！  
由于Android规定只有UI线程才能更新用户界面和接受用户的按钮及触摸事件！

private Looper() {  
    mQueue = new MessageQueue();  
    mRun = true;  
    mThread = Thread.currentThread();  
}

post(Runnable action)  
postDelay(Runnable action , long miliseconds)

runOnUiThread(Runnable action)

public final void runOnUiThread(Runnable action) {  
    if (Thread.currentThread() != mUiThread) {  
    //如果当前线程不是UI线程  
    mHandler.post(action);  
    } else {  
        action.run();  
    }  
}

mUiThread = Thread.currentThread() ;  
mHandler = new Handler()

public class PhotoDecodeRunnable implements Runnable {
    ...
    @Override
    public void run() {
        /*
         * Code you want to run on the thread goes here
         */
        ...
    }
    ...
}

class PhotoDecodeRunnable implements Runnable {
...
    /*
     * Defines the code to run for this task.
     */
    @Override
    public void run() {
        // Moves the current Thread into the background
        android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
        ...
        /*
         * Stores the current Thread in the PhotoTask instance,
         * so that the instance
         * can interrupt the Thread.
         */
        mPhotoTask.setImageDecodeThread(Thread.currentThread());
        ...
    }
...
}

public class PhotoManager {
    ...
    static  {
        ...
        // Creates a single static instance of PhotoManager
        sInstance = new PhotoManager();
    }
    ...

public class PhotoManager {
    ...
    /**
     * Constructs the work queues and thread pools used to download
     * and decode images. Because the constructor is marked private,
     * it's unavailable to other classes, even in the same package.
     */
    private PhotoManager() {
    ...
    }

public class PhotoManager {
    ...
    // Called by the PhotoView to get a photo
    static public PhotoTask startDownload(
        PhotoView imageView,
        boolean cacheFlag) {
        ...
        // Adds a download task to the thread pool for execution
        sInstance.
                mDownloadThreadPool.
                execute(downloadTask.getHTTPDownloadRunnable());
        ...
    }

private PhotoManager() {
    ...
        // Defines a Handler object that's attached to the UI thread
        mHandler = new Handler(Looper.getMainLooper()) {
            /*
             * handleMessage() defines the operations to perform when
             * the Handler receives a new Message to process.
             */
            @Override
            public void handleMessage(Message inputMessage) {
                ...
            }
        ...
        }
    }

public class PhotoManager {
...
    /*
     * Gets the number of available cores
     * (not always the same as the maximum number of cores)
     */
    private static int NUMBER_OF_CORES =
            Runtime.getRuntime().availableProcessors();
}

public class PhotoManager {
    ...
    private PhotoManager() {
        ...
        // A queue of Runnables
        private final BlockingQueue<Runnable> mDecodeWorkQueue;
        ...
        // Instantiates the queue of Runnables as a LinkedBlockingQueue
        mDecodeWorkQueue = new LinkedBlockingQueue<Runnable>();
        ...
    }
    ...
}

private PhotoManager() {
        ...
        // Sets the amount of time an idle thread waits before terminating
        private static final int KEEP_ALIVE_TIME = 1;
        // Sets the Time Unit to seconds
        private static final TimeUnit KEEP_ALIVE_TIME_UNIT = TimeUnit.SECONDS;
        // Creates a thread pool manager
        mDecodeThreadPool = new ThreadPoolExecutor(
                NUMBER_OF_CORES,       // Initial pool size
                NUMBER_OF_CORES,       // Max pool size
                KEEP_ALIVE_TIME,
                KEEP_ALIVE_TIME_UNIT,
                mDecodeWorkQueue);
    }

public class PhotoManager {
    public void handleState(PhotoTask photoTask, int state) {
        switch (state) {
            // The task finished downloading the image
            case DOWNLOAD_COMPLETE:
            // Decodes the image
                mDecodeThreadPool.execute(
                        photoTask.getPhotoDecodeRunnable());
            ...
        }
        ...
    }
    ...
}

class PhotoDecodeRunnable implements Runnable {
    // Defines the code to run for this task
    public void run() {
        /*
         * Stores the current Thread in the
         * object that contains PhotoDecodeRunnable
         */
        mPhotoTask.setImageDecodeThread(Thread.currentThread());
        ...
    }
    ...
}

public class PhotoManager {
    public static void cancelAll() {
        /*
         * Creates an array of Runnables that's the same size as the
         * thread pool work queue
         */
        Runnable[] runnableArray = new Runnable[mDecodeWorkQueue.size()];
        // Populates the array with the Runnables in the queue
        mDecodeWorkQueue.toArray(runnableArray);
        // Stores the array length in order to iterate over the array
        int len = runnableArray.length;
        /*
         * Iterates over the array of Runnables and interrupts each one's Thread.
         */
        synchronized (sInstance) {
            // Iterates over the array of tasks
            for (int runnableIndex = 0; runnableIndex < len; runnableIndex++) {
                // Gets the current thread
                Thread thread = runnableArray[taskArrayIndex].mThread;
                // if the Thread exists, post an interrupt to it
                if (null != thread) {
                    thread.interrupt();
                }
            }
        }
    }
    ...
}

/*
 * Before continuing, checks to see that the Thread hasn't
 * been interrupted
 */
if (Thread.interrupted()) {
    return;
}
...
// Decodes a byte array into a Bitmap (CPU-intensive)
BitmapFactory.decodeByteArray(
        imageBuffer, 0, imageBuffer.length, bitmapOptions);
...

private PhotoManager() {
...
    // Defines a Handler object that's attached to the UI thread
    mHandler = new Handler(Looper.getMainLooper()) {
    ...

/*
         * handleMessage() defines the operations to perform when
         * the Handler receives a new Message to process.
         */
        @Override
        public void handleMessage(Message inputMessage) {
            // Gets the image task from the incoming Message object.
            PhotoTask photoTask = (PhotoTask) inputMessage.obj;
            ...
        }
    ...
    }
}
The next section shows how to tell the Handler to move data.

// A class that decodes photo files into Bitmaps
class PhotoDecodeRunnable implements Runnable {
    ...
    PhotoDecodeRunnable(PhotoTask downloadTask) {
        mPhotoTask = downloadTask;
    }
    ...
    // Gets the downloaded byte array
    byte[] imageBuffer = mPhotoTask.getByteBuffer();
    ...
    // Runs the code for this task
    public void run() {
        ...
        // Tries to decode the image buffer
        returnBitmap = BitmapFactory.decodeByteArray(
                imageBuffer,
                0,
                imageBuffer.length,
                bitmapOptions
        );
        ...
        // Sets the ImageView Bitmap
        mPhotoTask.setImage(returnBitmap);
        // Reports a status of "completed"
        mPhotoTask.handleDecodeState(DECODE_STATE_COMPLETED);
        ...
    }
    ...
}
...

public class PhotoTask {
    ...
    // Gets a handle to the object that creates the thread pools
    sPhotoManager = PhotoManager.getInstance();
    ...
    public void handleDecodeState(int state) {
        int outState;
        // Converts the decode state to the overall state.
        switch(state) {
            case PhotoDecodeRunnable.DECODE_STATE_COMPLETED:
                outState = PhotoManager.TASK_COMPLETE;
                break;
            ...
        }
        ...
        // Calls the generalized state method
        handleState(outState);
    }
    ...
    // Passes the state to PhotoManager
    void handleState(int state) {
        /*
         * Passes a handle to this task and the
         * current state to the class that created
         * the thread pools
         */
        sPhotoManager.handleState(this, state);
    }
    ...
}

public class PhotoManager {
    ...
    // Handle status messages from tasks
    public void handleState(PhotoTask photoTask, int state) {
        switch (state) {
            ...
            // The task finished downloading and decoding the image
            case TASK_COMPLETE:
                /*
                 * Creates a message for the Handler
                 * with the state and the task object
                 */
                Message completeMessage =
                        mHandler.obtainMessage(state, photoTask);
                completeMessage.sendToTarget();
                break;
            ...
        }
        ...
    }