Android基础——多线程之IntentService_为什么用intentservice而不用线程-CSDN博客

本文链接：https://blog.csdn.net/memory_zhang/article/details/81509806

IntentService简介

public abstract class IntentService extends Service

IntentService 是一个抽象类，继承了Service，既然是一个Service,那么它的优先级会很高，不易被杀死；

下面是官方文档对他的介绍，大致总结如下

IntentService 是可以接受Intent，并异步处理请求的Service，通过startService(Intent)调用
如果不需要并发处理任务，IntentService是一个好的选择，通过继承IntentService，并实现onHandleIntent(Intent)，接受这些intents，并开启一个工作线程
IntentService只会创建一个，所有的请求都在这个工作线程中按照顺序执行，不会阻塞主线程loop，执行完之后工作线程就会停止

IntentService is a base class for Services that handle asynchronous requests (expressed as Intents) on demand. Clients send requests through Context.startService(Intent) calls; the service is started as needed, handles each Intent in turn using a worker thread, and stops itself when it runs out of work.

This "work queue processor" pattern is commonly used to offload tasks from an application's main thread. The IntentService class exists to simplify this pattern and take care of the mechanics. To use it, extend IntentService and implement onHandleIntent(Intent). IntentService will receive the Intents, launch a worker thread, and stop the service as appropriate.

All requests are handled on a single worker thread -- they may take as long as necessary (and will not block the application's main loop), but only one request will be processed at a time.

IntentService源码介绍

IntentService就是一个封装了HandlerThread的Service，下面按照源码介绍一下，源码一百多行，不是很难

1、首先是onCreat()方法，和创建HandlerThread一样，创建一个HandlerThread对象thread和异步mServiceHandler


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

2、从onStartCommand --> onStart，将startId和Intent传入到mServiceHandler

    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

这里注意到一个mRedelivery ，是从下面方法获得的

设置当前服务被意外关闭后是否重新
如果设置为 true，onStartCommand() 方法将返回 Service.START_REDELIVER_INTENT，当前进程在 onHandleIntent() 方法返回前销毁时，会重启进程，重新使用之前的 Intent 启动这个服务，如果有多个 Intent，只会使用最后的一个
如果设置为 false，onStartCommand() 方法返回 Service.START_NOT_STICKY，当进程销毁后也不重启服务

public void setIntentRedelivery(boolean enabled) {
    mRedelivery = enabled;
}

3、ServiceHandler 处理请求，执行onHandleIntent，最后一期启动该服务时调用stopSelf方法

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

最后贴一下整个源码，直观的感受一下

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(@Nullable 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(@Nullable 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
    @Nullable
    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)}.
     *               This may be null if the service is being restarted after
     *               its process has gone away; see
     *               {@link android.app.Service#onStartCommand}
     *               for details.
     */
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

IntentService 问题

看了源码之后可能会有很对问题，一一来解释一下先

启动 IntentService 为什么不需要新建线程？

IntentService内部的HandlerThread 继承自 Thread，内部封装了 Looper，在这里新建线程并启动，所以启动 IntentService 不需要新建线程。

为什么不建议通过 bindService() 启动 IntentService？

IntentService 源码中的 onBind() 默认返回 null；不适合 bindService() 启动服务，如果你执意要 bindService() 来启动 IntentService，可能因为你想通过 Binder 或 Messenger 使得 IntentService 和 Activity 可以通信，这样那么 onHandleIntent() 不会被回调，相当于在你使用 Service 而不是 IntentService

@Override
@Nullable
public IBinder onBind(Intent intent) {
    return null;
}

在 handleMessage 方法中不是调用了一次 onHandleIntent() 后就调用 stopSelf() 了吗，这不是只能执行一个任务么？

看下stopSelf()中传入一个startId参数，这个 id 是启动服务时 IActivityManager 分配的 id，当我们调用 stopSelf(id) 方法结束服务时，IActivityManager 会对比当前 id 是否为最新启动该服务的 id，如果是就关闭服务，所以最后一次启动IntentService执行任务完毕是会关闭服务

public final void stopSelf(int startId) {
    if (mActivityManager == null) {
        return;
    }
    try {
        mActivityManager.stopServiceToken(
                new ComponentName(this, mClassName), mToken, startId);
    } catch (RemoteException ex) {
    }
}

为什么多次启动 IntentService 会顺序执行请求，停止服务后，后续的事件得不到执行？

@Override
public void onDestroy() {
    mServiceLooper.quit();
}

IntentService按照顺序执行请求，查看onStart方法，内部实现Handler、Looper和MessageQueen消息机制，多级启动IntentService不会创建新的IntentService和新的线程，只是把请求加入到循环消息队列中顺序执行

停止服务后，执行onDestory方法，会清空消息队列中的消息，后续事件不会执行

特别注意的是，
除了onHandlerIntent方法，其他方法都是在主线程中执行
需要再AndroidManifest中注册
<service android:name=".MyIntentService" />
在IntentService中需要写默认构造函数
public MyIntentService(){
    super("MyIntentService");
}