IntentService

 参考： https://www.jianshu.com/p/3332f3357da0   https://github.com/LRH1993/android_interview/blob/master/android/basis/IntentService.md

一、概述

前面讲Service时提及IntentService，这里具体展开进行剖析；

1. IntentService的介绍
   • IntentService是自己维护了一个线程，来执行耗时的操作，然后里面封装了HandlerThread，能够方便在子线程创建Handler。
   • IntentService是继承自Service用来处理异步请求的一个基类，客户端startService发送请求，IntentService就被启动，然后会在一个工作线程中处理传递过来的Intent，当任务结束后就会自动停止服务。
2. IntentService的作用
   • 开启多线程
   • 执行异步请求逻辑

二、IntentService的使用

1. 定义IntentService的子类：传入线程名称、复写onHandleIntent()方法

**
 * Created by owen on 2017/5/1.
 */

public class MyIntentService extends IntentService {
    /**
     * 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
    protected void onHandleIntent(@Nullable Intent intent) {
        //复写onHandleIntent方法
        //实现耗时任务操作
        //打印当前的线程id
        String taskName = intent.getExtras().getString("taskName");
        Log.d("MyIntentService", "   Thread Id is : " + Thread.currentThread()
                .getId());
        switch (taskName) {
            case "task1":
                Log.i("myIntentService", "do task1");
                break;
            case "task2":
                Log.i("myIntentService", "do task2");
                break;
            default:
                break;
        }
    }

    @Override
    public void onCreate() {
        Log.i("myIntentService", "onCreate");
        super.onCreate();
    }

    /*复写onStartCommand()方法*/
    //默认实现将请求的Intent添加到工作队列里
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("myIntentService", "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyIntentService", "onDestroy executed");
    }
}

 

2. 在Manifest.xml中注册服务

如果报这个错

service has no default constructor

说明你没有在intentService继承类中复写无参的构造方法

 public MyIntentService() {
    ...............................
    }

 

3. 在Activity中开启Service服务

@Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.start_intent_service:
                //打印主线程id
                Log.d("ServiceMain ", " Thread id is " + Thread.currentThread()
                        .getId());
                startIntentService();
                break;
            default:
                break;
        }
    }

    private void startIntentService() {
        //同一服务只会开启一个工作线程
        //在onHandleIntent函数里依次处理intent请求。

        Intent i = new Intent("com.owen.stud");
        Bundle bundle = new Bundle();
        bundle.putString("taskName", "task1");
        i.putExtras(bundle);
        startService(i);

        Intent i2 = new Intent("com.owen.stud");
        Bundle bundle2 = new Bundle();
        bundle2.putString("taskName", "task2");
        i2.putExtras(bundle2);
        startService(i2);

        startService(i);  //多次启动
    }

 

三、IntentService原理

IntentService 源码很短：

 

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

　　 //内部创建的handler　
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
　　　　　　　//调用这个方法处理
　　　　　　  //onHandleIntent()是一个抽象方法，使用时需要重写的方法
            onHandleIntent((Intent)msg.obj);
            //处理完就自己结束自己
            stopSelf(msg.arg1);
        }
    }
    
 　 //子类需要重写的构造方法，参数时服务名
    public IntentService(String name) {
        super();
        mName = name;
    }

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

    @Override
    public void onCreate() {
        super.onCreate();
        //启动一个HandlerThread
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        //拿到子线程的Looper，创建一个子线程的handler
        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        //将intent和startId以消息的形式发给handler，即添加到消息队列里
        //这里的Intent 就是启动服务时startService(Intent) 里的 Intent

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

    @Override
    public void onDestroy() {
        mServiceLooper.quit();//清除消息队列中的消息
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }
    
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

 

 

 总结

从上面源码可以看出，IntentService本质是采用Handler & HandlerThread方式：

• 创建了一个 HandlerThread 默认的工作线程
• 使用 HandlerThread 的 Looper 创建了一个 Handler，这个 Handler 执行在子线程
• 在 onStartCommand() 中调用 onStart()，然后在 onStart() 中将 intent 和 startId 以消息的形式发送到 Handler
• 在 Handler 中将消息队列中的 Intent 按顺序传递给 onHandleIntent() 方法
• 在处理完所有启动请求后自动停止服务，不需要我们调用 stopSelf()

 因此我们通过复写方法onHandleIntent()，再在里面根据Intent的不同进行不同的线程操作就可以了

 注意事项：工作任务队列是顺序执行的

 如果一个任务正在IntentService中执行，此时你再发送一个新的任务请求，这个新的任务会一直等待直到前面一个任务执行完毕才开始执行。

  原因：

1. 由于onCreate() 方法只会调用一次，所以只会创建一个工作线程；
2. 当多次调用 startService(Intent) 时（onStartCommand也会调用多次）其实并不会创建新的工作线程，只是把消息加入消息队列中等待执行，所以，多次启动 IntentService 会按顺序执行事件；
3. 如果服务停止，会清除消息队列中的消息，后续的事件得不到执行。

 

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

public void handleMessage(Message msg) {
    onHandleIntent((Intent)msg.obj);
    stopSelf(msg.arg1);
}

 

 仔细看下可以发现，这个 stopSelf() 方法传递了一个 id，这个 id 是启动服务时 IActivityManager 分配的 id，当我们调用 stopSelf(id) 方法结束服务时，IActivityManager 会对比当前 id 是否为最新启动该服务的 id，如果是就关闭服务

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

 因此只有当最后一次启动 IntentService 的任务执行完毕才会关闭这个服务。

 此外还要注意的是，IntentService 中除了 onHandleIntent 方法其他都是运行在主线程的。

 

四、使用场景

• 线程任务需要按顺序、在后台执行的使用场景

  最常见的场景：离线下载

• 由于所有的任务都在同一个Thread looper里面来做，所以不符合多个数据同时请求的场景。

 

五、对比

1 IntentService与Service的区别

• 从属性 & 作用上来说 Service：依赖于应用程序的主线程（不是独立的进程 or 线程）

  不建议在Service中编写耗时的逻辑和操作，否则会引起ANR；

  IntentService：创建一个工作线程来处理多线程任务 　　

• Service需要主动调用stopSelft()来结束服务，而IntentService不需要（在所有intent被处理完后，系统会自动关闭服务）

2 IntentService与其他线程的区别

• IntentService内部采用了HandlerThread实现，作用类似于后台线程；

• 与后台线程相比，IntentService是一种后台服务，优势是：优先级高（不容易被系统杀死），从而保证任务的执行。

  对于后台线程，若进程中没有活动的四大组件，则该线程的优先级非常低，容易被系统杀死，无法保证任务的执行

 

后记

 一句话总结 IntentService：

• 优先级比较高的、用于串行执行异步任务、会自尽的 Service。

 

 

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

转载于:https://www.cnblogs.com/ivoo/p/10761207.html