Android IntentService 源码分析

IntentService简介：

IntentService是一个通过Context.startService(Intent)启动可以处理异步请求的Service,使用时你只需要继承IntentService和重写其中的onHandleIntent(Intent)方法接收一个Intent对象,该服务会在异步任务完成时自动停止服务.
所有的请求的处理都在IntentService内部工作线程中完成,它们会顺序执行任务(但不会阻塞主线程的执行),某一时刻只能执行一个异步请求。

IntnetService特点：

1.无需自己在Service中开启一个线程去处理耗时任务。

2.无需自己手动的去停止Service。

IntentService使用示例：

服务端代码如下：

package com.xjp.broadcast;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

/**
 * Description:
 * User: xjp
 * Date: 2015/5/4
 * Time: 15:47
 */

public class MyIntentService extends IntentService {

    private static final String TAG = "MyIntentService";

    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public MyIntentService() {
        super("TEST");
    }

    @Override
    public void onCreate() {
        Log.e(TAG, "====onCreate==");
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        Log.e(TAG, "====onDestroy==");
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "====onStartCommand==");
        Log.e(TAG, "====Current Thread Id==" + Thread.currentThread().getId());
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.e(TAG, "====onHandleIntent==");
        Log.e(TAG, "====Current Thread Id==" + Thread.currentThread().getId());

        /**
         * 此处模拟耗时任务执行
         */
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        int key = intent.getIntExtra("key", 0);

        Log.e(TAG, "====the key is ==" + key);
    }
}

客户端代码如下：

package com.xjp.broadcast;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends Activity {

    private Button startService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startService = (Button) findViewById(R.id.startService);
        startService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent service2 = new Intent(MainActivity.this, MyIntentService.class);
                service2.putExtra("key", 3);
                startService(service2);
            }
        });

    }

    @Override
    protected void onResume() {
        super.onResume();

        Intent service = new Intent(this, MyIntentService.class);
        service.putExtra("key", 1);
        startService(service);

        Intent service1 = new Intent(this, MyIntentService.class);
        service1.putExtra("key", 2);
        startService(service1);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

}

启动应用程序之后，打印如下：

我们发现：启动了两次服务，执行了一次onCreate， 两次 onStartCommand 且Thread id=1，说明服务是在UI线程执行， 执行了两次 onHandleIntent 且Thread id = 234，说明抽象方法 onHandleIntent 在子线程中执行，因此耗时任务可以在这里方法里去执行。且你会发现，当第二个任务执行完之后，打印输出  onDestory   说明该服务自动停止，无需人为去停止。

为什么 onHandleIntent 是在子线程中执行呢？什么时候创建了子线程？ 为什么IntentService 可以在 onHandleIntent 执行异步耗时任务？还有任务执行完之后为什么会自动停止Service？？接下来我们从源码角度解开神秘面纱吧！！！

IntentService 源码分析：

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.app;

import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;

/**
 * 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.
 *
 * <div class="special reference">
 * <h3>Developer Guides</h3>
 * <p>For a detailed discussion about how to create services, read the
 * <a href="{@docRoot}guide/topics/fundamentals/services.html">Services</a> developer guide.</p>
 * </div>
 *
 * @see android.os.AsyncTask
 */
public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

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

    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public IntentService(String name) {
        super();
        mName = name;
    }

    /**
     * Sets intent redelivery preferences.  Usually called from the constructor
     * with your preferred semantics.
     *
     * <p>If enabled is true,
     * {@link #onStartCommand(Intent, int, int)} will return
     * {@link Service#START_REDELIVER_INTENT}, so if this process dies before
     * {@link #onHandleIntent(Intent)} returns, the process will be restarted
     * and the intent redelivered.  If multiple Intents have been sent, only
     * the most recent one is guaranteed to be redelivered.
     *
     * <p>If enabled is false (the default),
     * {@link #onStartCommand(Intent, int, int)} will return
     * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent
     * dies along with it.
     */
    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

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

    /**
     * You should not override this method for your IntentService. Instead,
     * override {@link #onHandleIntent}, which the system calls when the IntentService
     * receives a start request.
     * @see android.app.Service#onStartCommand
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    /**
     * Unless you provide binding for your service, you don't need to implement this
     * method, because the default implementation returns null.
     * @see android.app.Service#onBind
     */
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * This method is invoked on the worker thread with a request to process.
     * Only one Intent is processed at a time, but the processing happens on a
     * worker thread that runs independently from other application logic.
     * So, if this code takes a long time, it will hold up other requests to
     * the same IntentService, but it will not hold up anything else.
     * When all requests have been handled, the IntentService stops itself,
     * so you should not call {@link #stopSelf}.
     *
     * @param intent The value passed to {@link
     *               android.content.Context#startService(Intent)}.
     */
    protected abstract void onHandleIntent(Intent intent);
}

我们看源码的第 107--111行：

IntentService内部实现了一个 HandlerThread 带有循环消息处理机制的线程。关于 HandlerThread 的原理和使用方法，请参考Android HandlerThread 源码分析 。因此，IntentService
内部其实也实现了一个带有循环消息处理机制的线程。看看我们客户端的耗时任务是怎么传给 IntentService 的内部 HandlerThread 线程执行的呢？ 我们每启动一次服务就执行一次 onStartCommand。

我们看源码的130行：

调用了 onStart方法。

我们看源码的115--120行：

onStart方法的实现， 在这个方法中，我们封装客户端传递过来的 Intent，将之通过 Handler + Message 消息处理机制  mServiceHandler.sendMessage(msg);  传递给 HandlerThread子线程去执行客户端的耗时任务。
我们看看 mServiceHandler 的实现

源码第58--68行：

实现了 mServiceHandler，构成了一个 Handler + Message + Looper 循环消息处理机制。

源码第65行：

调用了 带客户端的Intent消息参数的 onHandlerIntent 抽象方法，该抽象方法留给子类去实现相应的 异步耗时任务。因此，我们继承的IntentService 子类 必须实现 onHandlerIntent抽象方法。

源码第 66 行：

调用了stopSelf（）方法，当异步任务执行完之后，自动停止Servvice。因此，我们客户端无需自己去手动停止Service。

IntentService 总结：

IntentService 分析完毕，

1.其实内部就是实现了一个 HandlerThread+Handler 带有循环消息处理机制的线程去处理后台的耗时任务，无需用户去实现一个线程执行耗时任务。

2.并且任务执行之后 会自动 调用stopSelf停止服务，无需客户端去手动管理服务，客户端只需在需要执行异步后台耗时任务时，再次启动任务即可。

3.如果对 HandlerThread有所了解的童鞋就会知道，为什么 IntentService 执行异步任务都是顺序的，且一个时刻只能执行一个任务。因为HandlerThread + Handler 是一个单一的工作线程，也就是说，当客户端同时投放俩个异步任务时，只有前一个任务完成之后才能执行下一次任务，第二个任务是会阻塞等待的。不过是在子线程中执行，不会影响UI线程，也就不会出现ANR.