1. 前言
Broadcast Receiver用于接收并处理广播通知，众所周知，onReceive(Context curContext, Intent broadcastMsg)方法用于接受通知，并在该方法体内处理消息，但是onReceive中代码的执行时间不要超过5s，否则会报ANR错误，导致程序异常。一般这种情况，会有两个方案：
1）在onReceive方法中开启子线程，做耗时操作
2）在onReceive方法中启动新的Service，做耗时操作
第一种方式很明显不可行，因为BroadCastReceiver的生命周期很短，一旦被回收后，onReceive方法中开启的线程就成了空线程，当手机资源紧张回收资源时，空线程会被系统回收，导致子线程中的任务并不能顺利执行完毕就被杀死。
一般我们会用第二种方式，开启一个服务，但是我们知道servce也不能做耗时操作，难道我们在service再开启一个子线程吗？Google提供了IntentService类，帮我们做好了一切，我们只需要使用IntentSerivce即可，他内部帮我们开启了子线程,我们只需要重写onHandleIntent方法，在onHandleIntent方法中执行耗时操作。其实IntentService是使用了HandlerThread实现子线程耗时操作，如果对HandlerThread不熟悉，可以看上篇详细的介绍。
2.使用方法
1）继承IntentService
public class MyService extends IntentService 2）重写onHandleIntent（）方法
@Override
protected void onHandleIntent(Intent intent) {
//执行耗时操作
}全部代码如下所示：
/**
* Created by Administrator on 2018/5/31.
*/
public class MyService extends IntentService {
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
* @param name Used to name the worker thread, important only for debugging.
*/
public MyService(String name) {
super(name);
}
@Override
protected void onHandleIntent(Intent intent) {
//执行耗时操作
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onStart(Intent intent, int startId) {
super.onStart(intent, startId);
}
@Override
public void onCreate() {
super.onCreate();
}
}我们知道，当启动service后，会执行oncreate()->onStartCommand->onStart()方法，但是为什么我们的耗时操作却写在onHandlleIntent方法中，他内部是如何处理的呢，我们看下IntentService的源码。
3.源码讲解
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);
}代码非常少，我们开始分析。
1）首先，当启动IntentService的时候，会调用他的onCreate方法，如果看了上篇HandlerThread的使用代码，你应该会非常眼熟，他其实就是在创建HandlerThread，并通过创建出来的HandlerThread获取其中的Looper，通过Looper创建出mServiceHandler对象，因为Looper是在子线程中创建的，我们用该Looper对象创建出来的Handler自然持有异步线程的Looper，所有很正常，Hander的handleMessage方法可以执行耗时的异步操作。（如果还是不明白，可以详细看上篇，对于HandlerThread的介绍）。
2）onCreate方法执行完毕后，会执行onStartCommand方法，onStartCommand又会调用onStart方法，我们看下onStart方法体，里面其实就做了一件事，发送handler消息。接下来，肯定是看该mServiceHandler类的handlerMessage方法在哪里。mServiceHandler是内部类，handlerMessage方法里面调用了onHandleIntent方法，因为handlerMessage是在异步线程中，所以onHandleIntent方法也在异步线程中，并且onHandleIntent是个抽象方法，我们只要重写onHandleIntent方法体，即可实现异步线程处理耗时操作。
3）在onHandleIntent方法后面，我们看到，会再调用stopSelf(msg.arg1)方法，stopSelf(int startId)会等待所有消息都处理完后才终止服务,也就是说异步线程结束后，服务会自己关闭。
4)如果你多次startService，这时候，Service的生命周期是这样的：oncreate()->onStartCommand->onStart()>onStartCommand->onStart()>onStartCommand->onStart()...->onHandlerIntent()->onHandlerIntent()->onHandlerIntent()，很容易理解，这就是Service的生命周期，至于为什么onHandlerIntent方法为什么会多次被调用，因为每次调用onStart()，都会发送一次handler消息，而多次调用会，message会按照时间顺序存储在messageQueue单向链表中，Looper对象会不停的取出Message处理，即回调HandlerMessage方法，从而执行到onHandlerIntent方法，这边不清楚的，可以看前面源码角度讲解Android消息处理机制(Handler、Looper、MessageQueue与Message)。当多个消息都处理结束后，stopSelf(msg.arg1)方法执行后，service关闭，整个流程结束。