Service相信都不陌生，一说android四大组件,挂拉呱啦就出来了，IntentService就是Service的一个子类，本质是一个Service,只不过是内部封装了一些好用的功能，方面我们使用。google介绍IntentService可以用来处理异步请求，当工作线程结束之后，会自动停止服务。注意所有的请求都是在一个工作线程处理的，一次只能处理一个请求，所以如果前面的请求比较耗时，后面的请求就只能等待，如果有多个耗时请求，要谨慎使用。
下面就看一下IntentService源码，按照启动流程来分析吧，这样也好理解，
@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;
}1-13行，看一下onCreate()(只会执行一次)，创建HandlerThread（也就是工作线程,后面在分析），启动workthread,获取thread Looper,mServiceHandler绑定WorkThread.Looper,这里不就是我们常说的handler通讯机制的实现嘛，这不就是利用子线程的Handler和UIThread通讯的好例子嘛（看源码果然是好处大大滴），是不是没有执行Looper.prepare(),和Looper.loop()，不妨猜一下，有可能是在HandlerThread.run()中执行了这两个方法。mServiceHandler的作用也不难猜测吧，UIThread和WorkThread通讯;
30-33行，onStartCommand()（每次启动Service都会执行）,并且根据mRedelivery进行不同的策略配置，这里要注意：自定义的IntentService子类不要去重写onStartCommand()方法。
16-21行：onStart(),把startId和Intent作为Message参数发送给workThread;
为了验证我们关于Looper的猜想，追踪到HandlerThread看一下
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}没错吧，是在HandlerThread执行了Looper.prepare()，和Looper.loop()吧，之前的猜想完全正确。
再来说下onStartCommand中返回的int(也就是Service的策略模式)，在Service中有4种方案，在IntentService中只有2种可选，分别介绍一下各种策略工作模式：
这个整形可以有四个返回值：START_STICKY_COMPATIBILITY、START_STICKY、START_NOT_STICKY、START_REDELIVER_INTENT。
它们的含义分别是：
1):START_STICKY： 如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由 于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null，这里一定要注意Intent非空判断。
适用场景：在任意时间段，有显式的开启和停止，例如播放背景音乐
2):START_NOT_STICKY：“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，不会有新的Intent传送过来，系统不会自动重启该服务，也不会重新执行onStartCommand(),除非又调用Context#startService（），Service才会重新创建。
适用场景：如果我们某个Service执行的工作被中断无关紧要或者对Android内存紧张的情况下需要被杀掉且不会立即重新创建这种行为也可接受，那么我们便可将 onStartCommand的返回值设置为START_NOT_STICKY，
举个栗子：某个Service需要定时从服务器获取最新数据：通过一个定时器每隔指定的N分钟让定时器启动Service去获取服务端的最新数据。当执行到Service的onStartCommand时，在该方法内再设置一个N分钟后的定时器用于再次启动该Service并开辟一个新的线程去执行网络操作。假设Service在从服务器获取最新数据的过程中被Android系统强制杀掉，Service不会再重新创建，这也没关系，因为再过N分钟定时器就会再次启动该Service并重新获取数据，即：利用Service轮询服务器数据，就适合这种方案。
3):START_REDELIVER_INTENT：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Service被Kill之前最后一个传入onStartCommand的Intent的值重新传入。只要设置这种模式，onStartCommand(Intent, int, int)中的Intent一定不是null.
适用场景：如果我们的Service需要依赖具体的Intent才能运行（需要从Intent中读取相关数据信息等），并且在强制销毁后有必要重新创建运行，那么这样的Service就适合返回START_REDELIVER_INTENT
4):START_STICKY_COMPATIBILITY：START_STICKY的兼容版本，但不保证服务被kill后一定能重启。
这下明白了吧。
继续往下看声明周期：
@Override
public void onDestroy() {
mServiceLooper.quit();
}很简单的逻辑，当停止服务以后，在onDestory()中要停止Looper循环。
接下来，看一下内部的Handler做了什么工作
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
//抽象方法，需要子类重写，这个是在workThread
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
}的确在workThread工作完成后，自动停止服务，不需要我们再去停服。
重点看一下stopSelf(msg.arg1)也就是前面发送过来的msg.arg1 = startId;
/**
* Stop the service, if it was previously started. This is the same as
* calling {@link android.content.Context#stopService} for this particular service.
*
* @see #stopSelfResult(int)
*/
public final void stopSelf() {
stopSelf(-1);
}
/**
* Old version of {@link #stopSelfResult} that doesn't return a result.
*
* @see #stopSelfResult
*/
public final void stopSelf(int startId) {
if (mActivityManager == null) {
return;
}
try {
mActivityManager.stopServiceToken(
new ComponentName(this, mClassName), mToken, startId);
} catch (RemoteException ex) {
}
}startId,要么是-1，要么就是从1开始的连续增加的int数据，至于startId有什么用，怎么判断服务要不要停止，不妨猜想一下：只有当前的startId等于我们最后一次onStartCommand传递的startId,service才会停止，否则并不会停止service。
startId是怎么生成的，继续看这里
//ServiceRecord.java
private int lastStartId; // identifier of most recent start request.
public int getLastStartId() {
return lastStartId;
}
public int makeNextStartId() { // 此方法的调用是在ActiveServices中
lastStartId++;
if (lastStartId < 1) { // 通过代码我们可以看到startId是从1开始的正整数，每次+1
lastStartId = 1; // 你可以理解成客户端请求的次数(即startService调用的次数)
}
return lastStartId;
}至于对不对继续往下追踪
//ActivityManagerService.java
@Override
public boolean stopServiceToken(ComponentName className, IBinder token,
int startId) {
synchronized(this) {
return mServices.stopServiceTokenLocked(className, token, startId);
}
}继续追踪
//ActivityServices.java
boolean stopServiceTokenLocked(ComponentName className, IBinder token,
int startId) {
if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "stopServiceToken: " + className
+ " " + token + " startId=" + startId);
ServiceRecord r = findServiceLocked(className, token, UserHandle.getCallingUserId());
if (r != null) {
// 注意这个判断，和我们猜测的一样
if (startId >= 0) {
// Asked to only stop if done with all work. Note that
// to avoid leaks, we will take this as dropping all
// start items up to and including this one.
ServiceRecord.StartItem si = r.findDeliveredStart(startId, false);
if (si != null) {
while (r.deliveredStarts.size() > 0) {
ServiceRecord.StartItem cur = r.deliveredStarts.remove(0);
cur.removeUriPermissionsLocked();
if (cur == si) {
break;
}
}
}
if (r.getLastStartId() != startId) {
return false;
}
if (r.deliveredStarts.size() > 0) {
Slog.w(TAG, "stopServiceToken startId " + startId
+ " is last, but have " + r.deliveredStarts.size()
+ " remaining args");
}
}
synchronized (r.stats.getBatteryStats()) {
r.stats.stopRunningLocked();
}
r.startRequested = false;
if (r.tracker != null) {
r.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
SystemClock.uptimeMillis());
}
r.callStart = false;
final long origId = Binder.clearCallingIdentity();
bringDownServiceIfNeededLocked(r, false, false);
Binder.restoreCallingIdentity(origId);
return true;
}
return false;
}6行： 根据className,token获取ServiceRecord
9行：这个就是之前我们的startId
24行：是不是符合之前的猜想，当前startId != lastStartId,直接返回false,不会停止service,这也就解释了为啥非last startId不能让service停止的原因。
45行：真正停止服务的方法
写个Demo验证一下：
public class IntentSerivceDemo extends IntentService{
public IntentSerivceDemo() {
super("intent service demo");
}
public IntentSerivceDemo(String name) {
super(name);
}
@Override
protected void onHandleIntent(Intent intent) {
System.out.println(intent.toString()+",threadName:"+Thread.currentThread().getName());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public IBinder onBind(Intent intent) {
System.out.println("on bind.....");
return super.onBind(intent);
}
@Override
public void onCreate() {
super.onCreate();
System.out.println("on onCreate.....threadName:"+Thread.currentThread().getName());
}
@Override
public void onDestroy() {
System.out.println("on onDestroy.....");
super.onDestroy();
}
@Override
public void onStart(Intent intent, int startId) {
System.out.println("on onStart.....");
super.onStart(intent, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("on onStartCommand.....intent="+intent+"startId:"+startId);
return super.onStartCommand(intent, flags, startId);
}
}
//Activity
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent startServiceIntent = new Intent(this,IntentSerivceDemo.class);
startService(startServiceIntent);
Intent startServiceIntent2 = new Intent(this,IntentSerivceDemo.class);
startService(startServiceIntent2);
}
输出结果：
11-30 09:31:42.327 8989-8989/? I/System.out: on onCreate.....threadName:main
11-30 09:31:42.340 8989-8989/? I/System.out: on onStartCommand.....intent=Intent { cmp=com.charles_lun.db/.IntentSerivceDemo }startId:1
11-30 09:31:42.340 8989-8989/? I/System.out: on onStart.....
11-30 09:31:42.340 8989-9012/? I/System.out: Intent { cmp=com.charles_lun.db/.IntentSerivceDemo },threadName:IntentService[intent service demo]
11-30 09:31:42.341 8989-8989/? I/System.out: on onStartCommand.....intent=Intent { cmp=com.charles_lun.db/.IntentSerivceDemo }startId:2
11-30 09:31:42.341 8989-8989/? I/System.out: on onStart.....
11-30 09:31:47.342 8989-9012/? I/System.out: Intent { cmp=com.charles_lun.db/.IntentSerivceDemo },threadName:IntentService[intent service demo]
11-30 09:31:52.343 8989-8989/? I/System.out: on onDestroy.....IntentService其实里面没有什么复杂的东西，真正复杂的其实是在stopService这一步，好了，就分析这么多吧，希望对不清楚IntentService工作原理的同学有所帮助，鉴于水平有限，不对的地方请大大们指正。
1570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
