从源码分析IntentService

不管学什么知识点最好从其基本用法开始，然后在深入到源码层学习会比较容易理解源码带给我们的思想。所以咱们先来看看IntentService的基本用法。

其实很简单，遵守一定的套路就可以

1. 继承IntentService并生成构造方法通过super()来完成父类的基本初始化操作

2. 重写父类的onHandleIntent方法并执行需要完成的后台任务操作（上传文件等）

3. 重写onDestroy来完成些清理工作

比如：

public class MyIntentService extends IntentService {
    private static final String ACTION_BAZ = "com.example.comp.action.BAZ";

    private static final String EXTRA_PARAM1 = "com.example.comp.extra.PARAM1";
    private static final String EXTRA_PARAM2 = "com.example.comp.extra.PARAM2";

    public MyIntentService() {
        super("MyIntentService");
        setIntentRedelivery(false);
    }
    //用于启动此服务的辅助方法
    public static void startActionBaz(Context context, String param1, String param2) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_BAZ);
        intent.putExtra(EXTRA_PARAM1, param1);
        intent.putExtra(EXTRA_PARAM2, param2);
        context.startService(intent);
        Log.d("MyIntentService","startActionBaz");
        Log.d("MyIntentService","threadID:" + Thread.currentThread().getId());
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d("MyIntentService","onHandleIntent:" + Thread.currentThread().getId());
        if (intent != null) {
            final String action = intent.getAction();
            if (ACTION_BAZ.equals(action)) {
                final String param1 = intent.getStringExtra(EXTRA_PARAM1);
                final String param2 = intent.getStringExtra(EXTRA_PARAM2);
                handleActionBaz(param1, param2);
            }
        }
    }

    private void handleActionBaz(String param1, String param2) {
        Log.d("MyIntentService","handleActionBaz:" + Thread.currentThread().getId());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyIntentService","onDestroy:" + Thread.currentThread().getId());
    }
}
           

在前台activity中通过

MyIntentService.startActionBaz

来启动服务，大家可以注意log日志的输出查看对应的方法是在哪个线程中执行的（通常主[ui]线程id为1，如果在对应的方法中输出的线程id为1表明是在ui线程中执行的，那么千万就不要在这样的方法中执行费时操作了，以避免ANR[程序未响应]的异常）。

辅助方法中是通过startService来启动服务的，想必大家都知道在启动成功后将调用Service的onCreate和onStartCommand方法，那 我们就可以从这两个方法开始着手进入源码分析。

- IntentService.java

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

    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
    public void onDestroy() {
        mServiceLooper.quit();//退出Looper消息循环
    }
           

大概可以得出结论：

1. 启动Service时在onCreate方法中启动了一个HandlerThread的线程并生成了一个Looper用来分发消息之类的，同时创建了一个ServiceHandler的Handler用来处理消息

2. onStartCommand中调用了onStart方法，那么在onStart方法中做了些什么操作呢？

- IntentService.java

public void onStart(Intent intent, int startId) {

Message msg = mServiceHandler.obtainMessage();

msg.arg1 = startId;

msg.obj = intent;

mServiceHandler.sendMessage(msg);

}

很明显就是通过ServiceHandler来发送消息（发送到了HandlerThread的Looper消息队列中），消息携带了intent对象（start Service启动Service时的intent），那么有发送消息就一定有处理消息的代码。继续查看ServiceHandler的代码发现其是IntentService的内部类，定义如下：

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

可以看出在handleMessage中调用了onHandleIntent方法并在方法结束后stopSelf停止了Service。继续查看onHandleIntent方法的定义

IntentService.java

protected abstract void onHandleIntent(Intent intent);

OK，这个抽象方法必须在IntentService的子类中重写，那么在ServiceHandler的handleMessage中调用的将是子类中重写的onHandleIntent方法，所以在我们的MyIntentService类中的onHandleIntent方法被调用（通过Java的多态机制实现了一个“模版方法”的设计模式）

到此源码基本分析结束，可以得出结论如下：

1. 启动IntentService类型的Service后，系统通过ServiceHandler将携带的Intent消息放入由HandlerThread线程生成的Looper的消息队列中，Looper依次处理队列中的消息并通过dispatchMessage将消息交给ServiceHandler的Handler来具体执行（其实就是Handler的用法，和我们在Activity中创建Handler并在handleMessage中更新ui的用法一样，只不过这里的handleMessage是在HandlerThread这样的后台线程而不是ui线程中执行的）

2. 调用子类的onHandleIntent方法（用来执行费时操作），结束后关闭Service

总之，这种机制通常用于

希望按顺序执行（串行）而非并发（并行）执行的费时操作，其中每个任务执行完毕的时间是未知的

的应用场景。如果希望在任务结束后通知前台可以通过sendBroadCast的方式发送广播。

HandlerThread类的关键代码（Service的onCreate方法中创建并start启动了线程）：

/**
典型的创建Looper步骤：
//生成Looper实例
Looper.prepare();
Looper.myLooper();
//启动Looper循环
Looper.loop();
*/
public void run() {
    mTid = Process.myTid();
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();
    Looper.loop();
    mTid = -1;
}
public Looper getLooper() {
    if (!isAlive()) {
        return null;
    }
    synchronized (this) {
        while (isAlive() && mLooper == null) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}
           

这里比较难理解的是线程的安全同步代码，在onCreate方法中调用顺序如下：

HandlerThread thread = new HandlerThread();
thread.start();
thread.getLooper();
           

想必大家都知道线程的基本知识，这里就不多介绍了。在线程调用start后并不一定run方法立刻得到执行（异步调用的），所以在执行thread.getLooper()时这个时候run还没有执行。so，getLooper方法内部通过加锁并有条件的wait()来一直等待mLooper不为空。在run方法中可以看到如果mLooper被初始化后会调用notifyAll()来通知所有正处于wait的线程继续执行，这时getLooper方法中的return mLooper；将得到执行。