android_IntentService,AsyncTask,Handler

  //Service不是一个独立的进程(除非特别指定)，它与应用程序在同一进程中。Service不是一个线程，应该避免耗时操作。
  //IntentService以队列方式将请求的Intent加入队列，开启工作者执行任务，不会堵塞UI线程。  -----  （AsynTask）
  //IntentService是Serivce+handler的结合产物(只有一个线程执行任务)，AsyncTask是thread+handler的结合产物(多个线程执行任务，线程池)。
  //AsyncQueryService是后台执行ContentResolver调用的服务，减少因activity关闭而导致的调用的失败。AsyncQueryHandler在子线程中调用ContentResolver，支持增删改查，同样支持延时/取消执行。
  class AsyncQueryService extends Handler {
    public void startQuery() {
        AsyncQueryServiceHelper.queueOperation(mContext, info);
    }
  }
  public class AsyncQueryServiceHelper extends IntentService {
      static public void queueOperation(Context context, OperationInfo args) {
        // Set the schedule time for execution based on the desired delay.
        args.calculateScheduledTime();
        synchronized (sWorkQueue) {
            sWorkQueue.add(args);
            sWorkQueue.notify();
        }
        context.startService(new Intent(context, AsyncQueryServiceHelper.class));
    }
  }
     abstract class IntentService extends Service {  **** }
     OperationInfo implements Delayed {  **** }
         interface Delayed extends Comparable<Delayed> {  **** }   

  Handler两个主要用途(官网)：定时发送消息/执行任务(post--Runnable)；让不同的线程执行动作(sendMessage--Message)。
  Handler主要接收子线程发送的数据，并用此数据配合主线程更新UI。处理消息按照先进先出方式。
  Handler和多线程：post发送一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行该对象的run方法。也就是说，整个run中的操作和主线程处于同一个线程。   
  为了避免假死，handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装操作的对象被传递，并未产生新线程。

  public class HandlerThread extends Thread { **** }  //加入了Looper。即 消息队列+消息循环。
  public class Thread implements Runnable {  **** }  //实现run方法；启动调用start方法。
  HandlerThread使用方法(不当做一次性消耗品)：mHandlerThread.start();    mWorkerHandler=new WorkerHandler(mHandlerThread.getLooper());   mWorkerHandler.post(runnable);
  Activity中runOnUiThread方法：
  public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

  //Message中包含了 Runnable/Handler变量等。
  public final class Message implements Parcelable {
     public int what;
     public Object obj;
     Runnable callback;
     Handler target;
  }
  //Handler调用post方法，会封装为Message；sendMessage时，插入到MessageQueue队列，Message的hanlder变量被赋值。
  public class Handler {
     public boolean sendMessageAtTime( ** ){
        MessageQueue queue = mQueue;
        msg.target = this;
        sent = queue.enqueueMessage(msg, uptimeMillis);
        return sent;
    }
    private final Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }     
  }
  //Looper中有ThreadLocal变量。
  public class Looper {
     private static final ThreadLocal sThreadLocal = new ThreadLocal();
     final MessageQueue mQueue;
     Thread mThread;
     public static final void loop() {
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        while (true) {
            Message msg = queue.next(); // might block
            msg.target.dispatchMessage(msg);
            msg.recycle();
        }
  }

  退出Looper线程：mHandlerThread.getLooper().quit();