Handler与HandlerThread、IntentService源码解析

在前面的博客当中为大家分析过了Handler的源码，今天这篇博客的主要内容是为大家结合HandlerThread讲述一下Handler的另外一种比较酷炫的用法，以及这种酷炫的用法又是如何结合Service创造出IntentService这么酷的类的。

首先为大家总结一下前面Handler几个关键的核心知识点：
1、Handler是通过Handler的实例化对象进行线程间的切换的
2、Handler必须在主线程中创建,因为不在主线程中创建的Handler没有Loop，在Handler源码中设置就会报错。没有Loop就无法进行Handler最主要的消息机制
3、Handler消息的解释是通过Loop.loop（）方法中通过Handler的实例化对象（msg.target）回调去实现Runnable接口中的内容
4、不同的线程都有不同的Looper和相应的消息队列（MessageQueue），都存储在一个叫ThreadLocal的类当中

这些特性就解释了Handler应用的一些表面现象：
1、即使在不同的线程中只要是同一个Handler对象都能接收到同一个Handler对象所发的消息，因为消息的回调是通过Handler的实例化对象
2、即使在不同的界面，同样也能接收到消息，只要在同一个线程中就可以了，因为同一个线程用的是同一个消息队列所以能够收到消息。

复习完了Handler的知识点，下面给大家看一段酷炫的Handler的用法，代码如下：

HandlerThread handlerThread = new HandlerThread("HandlerThread");        Handler handler = new Handler(handlerThread.getLooper());        handler.post(new Runnable() {            @Override            public void run() {                Thread thread = Thread.currentThread();                System.out.println("threadIdRunnable = " + thread.getId());            }        });    }

这里给大家的思考就是Handler中的Runnbale接口执行的时候，里面的代码是在主线程执行的么？

答案当然是否定的，这段代码的执行时在HandlerThread子线程当中执行的，利用了消息队列的特性，即使Handler.post(new Runable())方法使用很多次，使消息队列中有很多消息，也不会产生线程不安全的问题，因为这是个消息队列，只会等一个消息执行完了再执行下一个消息，Handler的这种用法即避免了在主线程执行耗时操作，又避免了线程不安全的问题，是不是很酷。

那么就大家来分析一下能够产生这种效果的原因：

大家在前面应该看到了HandlerThread这个类，先给大家看一下HandlerThread这个类的源代码：

public class HandlerThread extends Thread {    int mPriority;    int mTid = -1;    Looper mLooper;    public HandlerThread(String name) {        super(name);        mPriority = Process.THREAD_PRIORITY_DEFAULT;    }     public HandlerThread(String name, int priority) {        super(name);        mPriority = priority;    }protected void onLooperPrepared() {    }    @Override    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;        }        // If the thread has been started, wait until the looper has been created.        synchronized (this) {            while (isAlive() && mLooper == null) {                try {                    wait();                } catch (InterruptedException e) {                }            }        }        return mLooper;    }    }

大家仔细看HandlerThread 这个类继承自Thread,和普通Thread唯一不同的地方就是在于这个类用于自己的Loop.
这下明白了，如果一个Handler使用了HandlerThread中的Loop，那么在当执行Hanndler中Runnable接口中的内容的时候。必须先执行Loop.loop()这个方法才能在当中利用Handler的实例化对象回调Runable接口中的内容。但是Loop.loop()这个方法由于Loop是HandlerThread的，所以Loop.loop()这个方法的调用必须是在HandlerThread中，这就解释了为什么说这个操作是在子线程当中。OK，为大家讲述完了Hanlder结合HandlerThread的酷炫用法.
下面为大家讲述IntentService，IntentService实际上是一个继承自Service的类，首先为大家先来复习一下关于Service的生命周期。主要讲述常用的几个生命周期，用StartService的方式启动服务
onCreate() 第一次启动服务的时候会回调这个方法
onStartCommand() 后面每次启动都会回调这个方法
onDestroy(） 服务销毁的时候会启动这个方法

那么大家来看看在IntentService的onCreate()这个方法里面做了什么样的操作呢？

@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 + "]");        thread.start();        mServiceLooper = thread.getLooper();        mServiceHandler = new ServiceHandler(mServiceLooper);    }

小伙伴们是不是惊呆了，没错，这个其实就是我上面为大家讲述的关于Handler的炫酷用法，在一个Handler了里面指定了一个HandlerThread的Loop，这样后面Hanlder方法里面的操作就在子线程里面了，还不会出现因为多线程带来的线程不安全的问题，因为Handler的处理机制是一个消息队列。

那在Service的生命周期onStartCommond里面做了什么呢，
大家情况源码：

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

回调了onStart()里面的内容,情况onStart()里面的代码：

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

onStart里面的操作竟然就是把intent和startId当做消息用Handler发了出去，大家请看消息的接收代码：

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（)这个方法，所以这也是为何我们使用IntentService的时候要重写这个方法，IntentServcie的精华就在于利用了Service这个组件在后台运行的特性，并且利用了Handler使用子线程的Looper的话，那么Handler里面的操作就是在子线程里面，并且利用Handler的消息队列机制避免了线程的不安全性。接着调用了stopSelf(）方法把自己这个服务干掉了，并且看onDestroy（)方法：

@Override    public void onDestroy() {        mServiceLooper.quit();    }

将这个消息队列的停止了，大家在这个过程中注意这一点避免内存泄露。