从源码分析IntentService
不管学什么知识点最好从其基本用法开始，然后在深入到源码层学习会比较容易理解源码带给我们的思想。所以咱们先来看看IntentService的基本用法。
其实很简单，遵守一定的套路就可以
- 继承IntentService并生成构造方法通过super()来完成父类的基本初始化操作
- 重写父类的onHandleIntent方法并执行需要完成的后台任务操作（上传文件等）
- 重写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消息循环
}
大概可以得出结论：
- 启动Service时在onCreate方法中启动了一个HandlerThread的线程并生成了一个Looper用来分发消息之类的，同时创建了一个ServiceHandler的Handler用来处理消息
- 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的多态机制实现了一个“模版方法”的设计模式）
到此源码基本分析结束，可以得出结论如下：
- 启动IntentService类型的Service后，系统通过ServiceHandler将携带的Intent消息放入由HandlerThread线程生成的Looper的消息队列中，Looper依次处理队列中的消息并通过dispatchMessage将消息交给ServiceHandler的Handler来具体执行（其实就是Handler的用法，和我们在Activity中创建Handler并在handleMessage中更新ui的用法一样，只不过这里的handleMessage是在HandlerThread这样的后台线程而不是ui线程中执行的）
- 调用子类的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；将得到执行。
