IntentService

在实际开发过程中会有这样的一个需求，我们需要运行一个任务，并且只需要在后台默默运行即可,那么这样的需求，我们一般会在 activity 中去开启一个线程，让其去跑这个任务，但是 activity 在被切换到后台并且因为内存不足时会被回收。不过还有一种方式可以解决那就是使用 Service 的方式实现，在 Service 中开启子线程执行耗时操作，并且 service 的优先级高， 不易被回收。不过 google 为了方便开发者使用，提供了一个 IntentService 这个类。下面是 google 对这个类的描述：

/**
 * IntentService is a base class for {@link Service}s that handle asynchronous
 * requests (expressed as {@link Intent}s) on demand.  Clients send requests
 * through {@link android.content.Context#startService(Intent)} calls; the
 * service is started as needed, handles each Intent in turn using a worker
 * thread, and stops itself when it runs out of work.
 *
 * <p>This "work queue processor" pattern is commonly used to offload tasks
 * from an application's main thread.  The IntentService class exists to
 * simplify this pattern and take care of the mechanics.  To use it, extend
 * IntentService and implement {@link #onHandleIntent(Intent)}.  IntentService
 * will receive the Intents, launch a worker thread, and stop the service as
 * appropriate.
 *
 * <p>All requests are handled on a single worker thread -- they may take as
 * long as necessary (and will not block the application's main loop), but
 * only one request will be processed at a time.
 */

简单理解：IntentService是继承Service异步请求任务类，内部维护了HandlerThread和Handler，可用于执行后台耗时任务。所有的请求都只会在一个单一的线程去执行，并且一次只会去执行一个请求，队列的方式顺序执行所有的任务完成之后会自己去停止服务。正在执行的任务是无法被打断的。使用IntentService 的好处就是不需要去手动的关闭服务，也免去了开启线程的工作，使用起来很方便

案例

• 自定义一个IntentService的子类MyIntentService

  IntentService 是一个抽象类，需要子类实现，并重写 onHandleIntent 方法，它是一个处理接收到服务的回调方法。

public class MyIntentService extends IntentService {
    public static final String TAG = MyIntentService.class.getSimpleName();

    public MyIntentService() {
        super(TAG);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
       
        if (intent != null) {
            String task = intent.getStringExtra("task");
            Log.e(TAG,"onHandleIntent:"+task);

            if("open".equals(task)) {
                //表示要处理的意图
                SystemClock.sleep(3000);
                Log.e(TAG,"要特殊处理的意图:"+task);
            }
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "MyIntentService 被销毁了");
    }
}

• 在清单文件配置，代码不贴了。
• 开启服务

Intent service = new Intent(this, MyIntentService.class);

service.putExtra("task", "close1");
startService(service);

service.putExtra("task", "close2");
startService(service);

service.putExtra("task", "open");
startService(service);

• 结果

从运行结果可以看出IntentService是逐个去执行任务的，只有最后一个任务执行完毕之后才会去停止服务

onHandleIntent:close1
onHandleIntent:close2
onHandleIntent:open
要特殊处理的意图:open
MyIntentService 被销毁了

源码分析

• IntentService#onCreate()

  服务第一次被创建就会执行 onCreate() 方法，其主要分为两步：第一步在该方法中创建线程HandlerThread，thread.start(); 并开启线程，查阅 HandlerThread#run() 方法源码可以知道，HandlerThread 绑定的 Looper 会调用 Looper.loop()开启轮训了，等待消息的到来。
  第二步是创建 ServiceHandler，并将该 ServiceHandler 绑定HandlerThread创建的Looper对象，这样通过mServiceHandler发送的消息会被发送到HandlerThread中的MessageQueue中。这两步就是在 IntentService 创建时的执行操作。

@Override
public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();//开启线程

    mServiceLooper = thread.getLooper();//拿到thread 绑定的 Looper 对象
    mServiceHandler = new ServiceHandler(mServiceLooper); //根据 Looper 创建 ServiceHandler 对象。
}

• 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;
}

• IntentService#onStart()

  服务创建之后就会去执行onStartCommand()方法，该方法会去调用onStart()方法。该方法接收到意图之后，将其包装成一个Message对象，然后发送到HandlerThread 对应的消息队列中，这样 ServiceHandler 将意图传递给onHandleIntent。浏览源码发现该方法是一个空方法，而且是需要子类去实现的。因为是在非 UI 线程去发送的 Message，因此该方法 handleIntent() 可以做一些耗时任务。
  注意：onHandleInten方法的Intent参数跟startService的Intent参数是同一个对象。

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

• mServiceHandler 是如何处理消息的？

  之前在 onStart 方法是通过 mServiceHandler.sendMessage 的方式发送消息的，因此会在该 Handler 中的 handleMessage 中去处理消息。在该方法中可以看到它将该 Message 中携带的 Intent 传入给 onHandleIntent 方法。

private final class ServiceHandler extends Handler {
    public ServiceHandler(Looper looper) {
        super(looper);
    }
    @Override
    public void handleMessage(Message msg) {
        onHandleIntent((Intent)msg.obj);
        stopSelf(msg.arg1);
    }
}

• Looper 轮训器已经开启轮训了，那么轮训到的 Message 是怎么通过 IntentService#ServiceHandler 是处理消息的？

private final class ServiceHandler extends Handler {
    public ServiceHandler(Looper looper) {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
        onHandleIntent((Intent)msg.obj);
        stopSelf(msg.arg1);//传递当前的id作为当前启动的任务停止服务的标记，不要去调用stopSelf()方法，这样会马上停止服务，有可能其他开启的服务还没执行完毕。
    }
}

ServiceHandler是一个Handler，从onCreate方法可以看出，ServiceHandler是绑定HandlerThread的Looper，也就是说它处于非UI线程，而是跟 HandlerThread 处于同一个线程。当轮训到 Messgae 时，会回调 handleMessage 方法，然后调用 onHandleIntent 将 msg.obj 作为参数传递过去。这个 msg.obj 就是通过 startService 传入的 Intent 对象。

• 多次启动服务是如何按顺序去执行服务的？

onCreate 方法只会在第一次开启时调用，多次开启服务是不会再次调用 onCreate 方法的，而是会去调用 onStart 方法，因此 IntentService 中的 HandlerThread 是同一个，也就是所有的任务都会一个线程中去执行。并且会共用一个 ServiceHandler 对象。每次开启任务，都会回调 onStart 方法，然后往消息队列中添加一个任务，但是你注意到在 handleMessage 中处理 完 onHandleIntent 之后会调用 stopSelf(msg.arg1) 这是不是意味着服务就被关闭了呢？其实不是，为什么使用 stopSelf(msg.arg1) 可以参考下面一点。

• onHandleIntent 执行完毕之后为什么是调用 stopSelf(msg.arg1)而不是 stopSelf() 呢？

  当onHandleIntent方法执行结束之后，IntentService会通过stopSelf（int startId）方法尝试停止服务。这里之所以采用stopSelf（int startId）而不是stopSelf（）来停止服务，那是因为stopSelf（）会立刻停止服务，而这个时候可能还有其他消息未处理，stopSelf（int startId）则会等待所有的消息都处理完毕之后才终止服务。一般来说，stopSelf（int startId）在尝试停止服务之前会判断最近启动服务的次数是否和startId相等，如果相等就立刻停止服务，不相等则不停止服务。