Service科普

你是不是一直都以为Service运行于子线程中的呢？那么这篇文章就是打你脸的，运行于后台并不代表运行于子线程。再说一遍，我大声的再说一遍，Service是运行在主线程中的。

我知道你不想相信，不敢相信，也不愿相信，心中千万只草泥马奔腾而过。卧槽，为什么前台没被阻塞？为什么没有出现ANR？为什么......
因为你没做耗时操作呀（虽然你是个傻瓜，可是爸爸依旧爱你(￣(ｴ)￣)）

那么如果有耗时的操作怎么办呢？
傻瓜，开子线程处理不就好了嘛。用HandlerThread就可以了呀。
那我岂不是还要重新写一堆代码嘞？
我亲爱的笨笨，现成的IntentService就可以解决你的问题，只要简单的实现onHandleIntent就可以啦。
那亲爱的爸爸你快给我讲讲怎么用吧。
恩，乖儿子。爸爸先给你缕缕（这里的故事只有懂得人知道），再教你具体怎么使用好吧。

HandlerThread

这是一种可以使用Handler的Thread。如果对我之前那篇《记一次Handler优化》文章熟悉的朋友，可能就很容易明白为什么了。

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();// 注意下，在子线程中prepare，就可以为子线程设置消息循环机制了
        synchronized (this) {
            mLooper = Looper.myLooper();// 获取到当前线程的Looper对象
            notifyAll();// 释放等待队列中的线程（即主线程），此线程进入锁池状态
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();// 在消息循环开启之前可以做准备工作
        Looper.loop();// 开始消息循环
        mTid = -1;
    }

外界只要通过Handler发送消息，就可以让HandlerThread执行一个具体任务了。

IntentService

我们可以注意到IntentService的头注释中这么一段话：

 * 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 {@link #onHandleIntent(Intent)}. IntentService
 * will receive the Intents, launch a worker thread, and stop the service as
 * appropriate.

大概意思就是说IntentService使用的是工作队列处理器的模式，通常用于执行后台任务。最简单的使用方式就是继承并重写onHandleIntent方法，并能在适当的时候停止。
同时IntentService是服务，适合执行一些高优先级的任务，不容易被系统杀死，这是单纯的线程无法比拟的。

接下来我们来揭开它神秘的面纱。

    @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 + "]");// 实例化一个HandlerThread
        thread.start();// 线程就绪准备运行，等待CPU调度

        mServiceLooper = thread.getLooper();// getLooper方法会通过临界资源的wait，导致主线程放弃该对象的锁标记，进入等待队列直到HandlerThread中mLooper初始化完成调用notifyAll释放主线程
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

我们注意到，最后一步将子线程的Looper对象关联进了ServiceHandler中，那么ServiceHandler中又发生了什么呢？

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);// 将我们当前工作线程HandlerThread的Looper循环器关联到Handler中，Handler就会使用该Looper进行消息的循环
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);// 重写onHandleIntent；根据Intent去执行我们的耗时任务
            stopSelf(msg.arg1);// 任务执行完会自动停止
        }
    }

我们熟知每次Service启动，就会调用一次onStartCommand，这里是发送消息的最佳时机

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

    @Override
    public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);// 发送消息给HandlerThread线程处理
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();// 停止消息队列的循环
    }