IntentService

一、概述

前面讲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 android:name=".service.MyIntentService" >
            <intent-filter>
                <action android:name="com.owen.stud"/>
            </intent-filter>
        </service>

如果报这个错

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,当进程销毁后也不重启服务
posted @ 2019-04-24 23:32  Ivo-oo  阅读(114)  评论(0编辑  收藏  举报