从源码分析IntentService

不管学什么知识点最好从其基本用法开始，然后在深入到源码层学习会比较容易理解源码带给我们的思想。所以咱们先来看看IntentService的基本用法。

其实很简单，遵守一定的套路就可以

1. 继承IntentService并生成构造方法通过super()来完成父类的基本初始化操作
2. 重写父类的onHandleIntent方法并执行需要完成的后台任务操作（上传文件等）
3. 重写onDestroy来完成些清理工作

比如：

    public class MyIntentService extends IntentService {
        private static final String ACTION_BAZ = "com.example.comp.action.BAZ";

        private static final String EXTRA_PARAM1 = "com.example.comp.extra.PARAM1";
        private static final String EXTRA_PARAM2 = "com.example.comp.extra.PARAM2";

        public MyIntentService() {
            super("MyIntentService");
            setIntentRedelivery(false);
        }
        //用于启动此服务的辅助方法
        public static void startActionBaz(Context context, String param1, String param2) {
            Intent intent = new Intent(context, MyIntentService.class);
            intent.setAction(ACTION_BAZ);
            intent.putExtra(EXTRA_PARAM1, param1);
            intent.putExtra(EXTRA_PARAM2, param2);
            context.startService(intent);
            Log.d("MyIntentService","startActionBaz");
            Log.d("MyIntentService","threadID:" + Thread.currentThread().getId());
        }

        @Override
        protected void onHandleIntent(Intent intent) {
            Log.d("MyIntentService","onHandleIntent:" + Thread.currentThread().getId());
            if (intent != null) {
                final String action = intent.getAction();
                if (ACTION_BAZ.equals(action)) {
                    final String param1 = intent.getStringExtra(EXTRA_PARAM1);
                    final String param2 = intent.getStringExtra(EXTRA_PARAM2);
                    handleActionBaz(param1, param2);
                }
            }
        }

        private void handleActionBaz(String param1, String param2) {
            Log.d("MyIntentService","handleActionBaz:" + Thread.currentThread().getId());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onDestroy() {
            super.onDestroy();
            Log.d("MyIntentService","onDestroy:" + Thread.currentThread().getId());
        }
    }

在前台activity中通过 MyIntentService.startActionBaz来启动服务，大家可以注意log日志的输出查看对应的方法是在哪个线程中执行的（通常主[ui]线程id为1，如果在对应的方法中输出的线程id为1表明是在ui线程中执行的，那么千万就不要在这样的方法中执行费时操作了，以避免ANR[程序未响应]的异常）。
辅助方法中是通过startService来启动服务的，想必大家都知道在启动成功后将调用Service的onCreate和onStartCommand方法，那 我们就可以从这两个方法开始着手进入源码分析。

• IntentService.java

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

        public int onStartCommand(Intent intent, int flags, int startId) {
            onStart(intent, startId);
            return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
        }
        public void onDestroy() {
            mServiceLooper.quit();//退出Looper消息循环
        }

大概可以得出结论：

1. 启动Service时在onCreate方法中启动了一个HandlerThread的线程并生成了一个Looper用来分发消息之类的，同时创建了一个ServiceHandler的Handler用来处理消息
2. onStartCommand中调用了onStart方法，那么在onStart方法中做了些什么操作呢？

• IntentService.java

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

很明显就是通过ServiceHandler来发送消息（发送到了HandlerThread的Looper消息队列中），消息携带了intent对象（start Service启动Service时的intent），那么有发送消息就一定有处理消息的代码。继续查看ServiceHandler的代码发现其是IntentService的内部类，定义如下：

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

可以看出在handleMessage中调用了onHandleIntent方法并在方法结束后stopSelf停止了Service。继续查看onHandleIntent方法的定义
IntentService.java
protected abstract void onHandleIntent(Intent intent);
OK，这个抽象方法必须在IntentService的子类中重写，那么在ServiceHandler的handleMessage中调用的将是子类中重写的onHandleIntent方法，所以在我们的MyIntentService类中的onHandleIntent方法被调用（通过Java的多态机制实现了一个“模版方法”的设计模式）

到此源码基本分析结束，可以得出结论如下：

1. 启动IntentService类型的Service后，系统通过ServiceHandler将携带的Intent消息放入由HandlerThread线程生成的Looper的消息队列中，Looper依次处理队列中的消息并通过dispatchMessage将消息交给ServiceHandler的Handler来具体执行（其实就是Handler的用法，和我们在Activity中创建Handler并在handleMessage中更新ui的用法一样，只不过这里的handleMessage是在HandlerThread这样的后台线程而不是ui线程中执行的）
2. 调用子类的onHandleIntent方法（用来执行费时操作），结束后关闭Service
   总之，这种机制通常用于希望按顺序执行（串行）而非并发（并行）执行的费时操作，其中每个任务执行完毕的时间是未知的的应用场景。如果希望在任务结束后通知前台可以通过sendBroadCast的方式发送广播。

HandlerThread类的关键代码（Service的onCreate方法中创建并start启动了线程）：

    /**
    典型的创建Looper步骤：
    //生成Looper实例
    Looper.prepare();
    Looper.myLooper();
    //启动Looper循环
    Looper.loop();
    */
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

这里比较难理解的是线程的安全同步代码，在onCreate方法中调用顺序如下：

    HandlerThread thread = new HandlerThread();
    thread.start();
    thread.getLooper();

想必大家都知道线程的基本知识，这里就不多介绍了。在线程调用start后并不一定run方法立刻得到执行（异步调用的），所以在执行thread.getLooper()时这个时候run还没有执行。so，getLooper方法内部通过加锁并有条件的wait()来一直等待mLooper不为空。在run方法中可以看到如果mLooper被初始化后会调用notifyAll()来通知所有正处于wait的线程继续执行，这时getLooper方法中的return mLooper；将得到执行。