Android线程—IntentService的使用及原理

本文内容基于《Android开发艺术探索》，强烈推荐，值得一看。

IntentService是继承自Service的抽象类，内部封装了HandlerThread和Handler，可以用来执行后台耗时的任务。它的优点是优先级高不容易被杀死，IntentService可以处理多个任务，只不过是一个接着一个的顺序来处理的，当任务完成后会自动停止，不需要主动调用stopSelft()来结束服务。onHandlerIntent是它的一个抽象方法，它可以从Intent中传入的参数来区分并执行任务。

1.使用方法

1).MyIntentService.java

public class MyIntentService extends IntentService {  

    private static final String TAG = MyIntentService.class.getSimpleName();  
    public static final int OPERATION_CODE_1 = 1;
    public static final int OPERATION_CODE_2 = 2;  

    public MyIntentService() {
        super("MyIntentService");
    }  

    @Override
    public void onCreate() {
        Log.e(TAG, "onCreate");
        super.onCreate();
    } 

    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind");
        return super.onBind(intent);
    }  

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand * " + startId);
        return super.onStartCommand(intent, flags, startId);
    } 

    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG, "onUnbind");
        return super.onUnbind(intent);
    } 

    @Override
    public void onDestroy() {
        Log.e(TAG, "onDestroy");
        super.onDestroy();
    } 

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.e(TAG, "onHandleIntent");
        int operateCode = intent.getIntExtra("operateCode", 0);
        switch (operateCode) {
            case OPERATION_CODE_1:
                Log.e(TAG, "OPERATION_CODE_1");
                break;
            case OPERATION_CODE_2:
                Log.e(TAG, "OPERATION_CODE_2");
                break;
            default:
                break;
        }  

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }  

}

2).MainActivity.java

public class MainActivity extends AppCompatActivity {  

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }  

    public void operate1(View view) {
        Intent operateIntent = new Intent(this, MyIntentService.class);
        operateIntent.putExtra("operateCode", 1);
        startService(operateIntent);
    }  

    public void operate2(View view) {
        Intent operateIntent1 = new Intent(this, MyIntentService.class);
        operateIntent1.putExtra("operateCode", 1);
        startService(operateIntent1);  

        Intent operateIntent2 = new Intent(this, MyIntentService.class);
        operateIntent2.putExtra("operateCode", 2);
        startService(operateIntent2);
    }  

}

在activity_main中添加了两个按钮，对应operate1、operate2方法，operate1是单任务，operate2是多任务，运行一下看看具体的log输出，先点击operate1看看单任务的log输出：

03-17 20:43:10.070 19856-19856/? E/MyIntentService: onCreate
03-17 20:43:10.072 19856-19856/? E/MyIntentService: onStartCommand * 1
03-17 20:43:10.073 19856-20279/? E/MyIntentService: onHandleIntent
03-17 20:43:10.073 19856-20279/? E/MyIntentService: OPERATION_CODE_1
03-17 20:43:16.076 19856-19856/? E/MyIntentService: onDestroy

再执行operate2看看多任务的log输出：

03-17 20:46:55.452 19856-19856/? E/MyIntentService: onCreate
03-17 20:46:55.453 19856-19856/? E/MyIntentService: onStartCommand * 1
03-17 20:46:55.453 19856-19856/? E/MyIntentService: onStartCommand * 2
03-17 20:46:55.453 19856-20991/? E/MyIntentService: onHandleIntent
03-17 20:46:55.453 19856-20991/? E/MyIntentService: OPERATION_CODE_1
03-17 20:47:01.453 19856-20991/? E/MyIntentService: onHandleIntent
03-17 20:47:01.453 19856-20991/? E/MyIntentService: OPERATION_CODE_2
03-17 20:47:07.456 19856-19856/? E/MyIntentService: onDestroy

从输入的日志中我们可以了解到，IntentService任务结束后会自动销毁，多任务的时候是一个一个顺序执行的，上一个任务的onHandleIntent执行完成才会调用下一个任务的onHandleIntent。

2.工作原理

onCreate()方法如下所示

public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

IntentService第一次启动时会调用onCreate方法，创建一个HandlerThread(不熟悉的同学可以参考Android线程—HandlerThread的使用及原理)对象，并开启HandlerThread线程，然后使用HandlerThread的Looper对象初始化mServiceHandler对象，通过mServiceHandler发送消息在HandlerThread中执行操作，所以虽然IntentService也是Service但是可以执行耗时操作。每次启动IntentService都会调用onStartCommand()方法，onStartCommand方法会调用onStart方法
onStart方法如下所示

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

我们可以发现onStart方法中只是调用mServiceHandler发送了一个消息，交给HandlerThread处理，这里传入的参数intent即为外界通过startIntent(intent)传入的intent，startId是当前IntentService的启动次数，第一次为1、第二次为2... 。
接下来我们看一下ServiceHandler的实现

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

onHandleIntent的一个抽象方法，我们在子类中实现具体功能，该方法执行完以后会尝试调用stopSelf(startId)方法来终止服务。（stopSelf(int startId)与stopSelf()的区别：stopSelf()直接停止；stopSelf(startId)只有在startId与最后启动该service时生成的startId相等时才会执行停止服务，即所有消息都处理完成）。因为IntentService每启动一次都会发送一个消息请求HandlerThread执行，Looper是顺序处理消息的，这就意味着IntentService执行多个任务时也是顺序执行的。

本人技术有限，欢迎指正，谢谢！