IntentService和HandlerThread

简介

IntentService是Service的子类，用来处理异步请求，客服端通过startService（Intent intent）发送请求，IntentService在需要的时候创建，在工作线程（HandlerThread）中处理每个请求，处理完成后IntentService自动关闭；

IntentService内部有一个子线程（HandlerThread ）和Handler（ServiceHandler）;

所有的请求在一个单一线程中处理，同一时间只能处理一个请求，不会阻塞主线程。

先介绍下HandlerThread；

HandlerThread是Thread的子类，内部包含有Looper，该Looper可以被用来创建HandlerThread的Handler,HandlerThread的用法和普通Thread的用法一样；

HandlerThread作为普通的Thread使用

private void start() {
  MyHandlerThread handlerthread = new MyHandlerThread("HandlerThread");
  handlerthread.start();
}

class MyHandlerThread extends HandlerThread {
  public MyHandlerThread(String name) {
    super(name);
  }
  @Override
  public void run() {
  try {
    String name = Thread.currentThread().getName();
    Log.e(tag, name + ":执行开始");
    Thread.sleep(3000);
    Log.e(tag, name + ":执行结束");
  } catch (InterruptedException e) {
    e.getStackTrace();
  }
}

HandlerThread配合Handler使用，Handler的handlerMessage方法也是在该子线程中运行，可以做耗时任务；

private void startHandlerThread() {
  HandlerThread handlerthread = new HandlerThread("HandlerThread");
  handlerthread.start();
  handler = new Handler(handlerthread.getLooper(), new MyCallable());
  handler.sendEmptyMessage(100);
}

在子线程运行的handleMessage；

class MyCallable implements Handler.Callback {
  @Override
  public boolean handleMessage(Message msg) {
    switch (msg.what) {
      case 100:
        try {
          Thread.sleep(1000);
          Log.e(tag, "HandlerThread的handleMessage执行耗时任务完成");
        } catch (InterruptedException e) {
          e.getStackTrace();
        }
        UIHandler.sendEmptyMessage(101);
      break;
    }
    //true:handleMessage不处理消息，false:handleMessage处理消息
    return false;
  }
}

MyCallablede的返回值true:handleMessage不处理消息，false:handleMessage处理消息

HandlerThread的run()方法中加锁。

@Override
public void run() {
  mTid = Process.myTid();
  Looper.prepare();
  synchronized (this) {
    mLooper = Looper.myLooper();
    notifyAll();//唤醒等待线程
  }
  Process.setThreadPriority(mPriority);
  onLooperPrepared();
  Looper.loop();
  mTid = -1;
}

返回和线程关联的Looper

public Looper getLooper() {
  //true：线程已经开始了，任然在运行中；false：没有开始或者已经died;
  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;
}

getLooper()返回和线程关联的Looper，当线程没有开始或者已经die将直接返回null;当线程已经调用start()但是mLooper==null;调用wait()方法，线程阻塞；否则返回当前线程mLooper；

run()方法中调用Looper.prepare();然后获取当前myLooper，获取之后notifyAll()，唤醒等待线程；

HandlerThread和Handler配合使用就是相当于在子线程中开启Handler,对Handler机制不了解的可阅读Handler消息机制

声明周期

和Service通过startService()方式开启的一样，不了解Service的用法可阅读Service常见用法分析

使用：

重写IntentService中的OnHandlerIntent(Intent intent)做耗时操作；

根据传入的Intent选择具体的操作

@Override
protected void onHandleIntent(Intent intent) {
  if (intent != null) {
    String action = intent.getAction();
    if ("my_intent_service".equals(action)) {
       dealData();
    }
  }
}

private void dealData() {
    try {
       //模拟耗时任务
       Log.e(TAG, "开始一次耗时任务");
       Thread.sleep(3000);
       Log.e(TAG, "完成一次耗时任务");
    } catch (InterruptedException e) {
       Log.e(TAG, Log.getStackTraceString(e));
     }
}

可以验证IntentService内部同一时间只能处理一个请求 ；并且在任务处理完之后，会调StopSelf()关闭服务；

注意下：回调完成后回调用 stopSelf(msg.arg1)，注意这个msg.arg1是个int值，相当于一个请求的唯一标识。每发送一个请求，会生成一个唯一的标识，然后将请求放入队列，当全部执行完成(最后一个请求也就相当于getLastStartId == startId)，或者当前发送的标识是最近发出的那一个（getLastStartId == startId），则会销毁我们的Service.如果传入的是-1则直接销毁。在Ondestory()中 mServiceLooper.quite();退出looper循环；备注：多个任务在等待执行，调用stopService()，会将已经开始的任务继续执行完，未开始的任务，不再执行；

源码分析

@Override
public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

初始化线程和Handler；由于Oncreate()只执行一次；所以线程中只有一个子线程；所以所有的请求在一个单一线程中处理，同一时间只能处理一个请求，不会阻塞主线程。

在onStartCommand()中调用onstart()方法；

@Override
public void onStart(Intent intent, int startId) {
    Message msg = mServiceHandler.obtainMessage();
    msg.arg1 = startId;
    msg.obj = intent;
    mServiceHandler.sendMessage(msg);
}

发送Handler消息，然后Handler的handleMessage处理消息，执行onHandleIntent()方法，重写的onHandleIntent()内做耗时操作；

以上就是IntentService的用法和内部源码分析，如有问题，请多指教！

源码