IntentService与普通的Service最大的区别在于，通过startService启动的普通Service，如果不主导调stopService方法，那么这个service会在后台一直存在。 而通过startService启动的IntentService，他在执行完所有异步任务后，会自己销毁。
通过查看源码，我们知道 IntentService 实际上是继承了Service类的，他与普通Service不同的是，它定义了一个ServiceLooper和ServiceHandler。
当我们启动一个IntentService的时候，首先会进入Service的onCreate方法，我们来看看IntentService在onCreate方法里都做了些什么。
@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);
}
从代码中可以看到，它创建一个HandlerThread的线程，然后直接启动这个线程，
然后再初始化上面说的mServiceLooper和mServiceHandler.（如果不知道handler,looper工作原理的自行查阅）。
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);//handler使用的looper是HandlerThread里的，
//也就是说使用该handler发送的消息都会到 HandlerThread 的 Looper的 MessageQueue中。
在HandlerThread的run方法中，Looper.loop() 进入循环等待mServiceHandler发送的消息
。
当有消息会回调到mServiceHandler的handleMessage方法中，在这里
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
有一个抽象方法 onHandleIntent 去处理异步任务，同时会调用stopSelf(msg.arg1);去停止服务，但是这个服务不是直接停止，需要等所有的异步任务 处理完成之后才会去销毁自己。 待会我们用代码去验证这一点。
当IntentService中所有的异步任务都执行完成后，会销毁掉。 那我们启动的HandlerThread什么时候销毁呢，如果不销毁每启动一次IntentService创建个异步线程，那显然是不合理的。 关键就在于IntentSerice的 onDestory方法。
@Override
public void onDestroy() {
mServiceLooper.quit();
}
对应到looper中的quit方法
/**
* Quits the looper.
* <p>
* Causes the {@link #loop} method to terminate without processing any
* more messages in the message queue.
* </p><p>
* Any attempt to post messages to the queue after the looper is asked to quit will fail.
* For example, the {@link Handler#sendMessage(Message)} method will return false.
* </p><p class="note">
* Using this method may be unsafe because some messages may not be delivered
* before the looper terminates. Consider using {@link #quitSafely} instead to ensure
* that all pending work is completed in an orderly manner.
* </p>
*
* @see #quitSafely
*/
public void quit() {
mQueue.quit(false);
}
这样，looper就退出循环了。HandlerThread run方法执行完也就销毁了。
下面通过例子来看，定义一个IntentService：
public class MyIntentService extends IntentService {
public MyIntentService(){
super("MyIntentService");
}
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
* @param name Used to name the worker thread, important only for debugging.
*/
public MyIntentService(String name) {
super(name);
}
@Override
public void onStart(@Nullable Intent intent, int startId) {
super.onStart(intent, startId);
Log.i("dx startId",String.valueOf(startId));
}
@Override
protected void onHandleIntent(@Nullable Intent intent) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.i("dx", String.valueOf(Thread.currentThread().getId()));
}
@Override
public void onDestroy() {
super.onDestroy();
Log.i("dx onDestroy","onDestroy");
}
}
我们在onHandleIntent 让工作线程停止两秒来模拟耗时任务，然后打印出当前工作线程的pid。
在activity中定义一个图片的点击事件，每点击一次，启动一次IntentService
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this,MyIntentService.class);
startService(intent);
}
});
我们点击一次。
可以看到，Service的销毁是在异步任务结束之后才销毁的。
我们再快速连续点击三次，启动三次Service：
通过log我们可以看到，当service启动后，如果它还在执行异步任务，没有销毁，你再次启动它，他是不会走onCreate方法的。 因为这三次打印出来的pid都是同一个，说明HandlerThread 还是第一次new出来的那个。 当过了6秒，三个异步任务都执行完之后，我们的IntentService才销毁。
