Android HandlerThread和IntentService

HandlerThread
HandlerThread继承了Thread,它是一种可以使用Handler的Thread，它实现也很简单，就是在run中通过Looper.prepare()来创建消息队列，并且通过Looper.loop()来开启消息循环，这样再实际使用中就允许在HandlerThread中创建Handle了。

1public class HandlerThread extends Thread {
2    int mPriority;
3    int mTid = -1;
4    Looper mLooper;
5    private @Nullable Handler mHandler;
6
7    public HandlerThread(String name) {
8        super(name);
9        mPriority = Process.THREAD_PRIORITY_DEFAULT;
10    }
11
12    public HandlerThread(String name, int priority) {
13        super(name);
14        mPriority = priority;
15    }
16
17    protected void onLooperPrepared() {
18    }
19
20    @Override
21    public void run() {
22        mTid = Process.myTid();
23        Looper.prepare();
24        synchronized (this) {
25            mLooper = Looper.myLooper();
26            notifyAll();
27        }
28        Process.setThreadPriority(mPriority);
29        onLooperPrepared();
30        Looper.loop();
31        mTid = -1;
32    }
33
34    public Looper getLooper() {
35        //Thread.IsAlive属性 ，表示该线程当前是否为可用状态
36        //如果线程已经启动，并且当前没有任何异常的话，则是true，否则为false
37        //Start()后，线程不一定能马上启动起来，也许CPU正在忙其他的事情，但迟早是会启动起来的！
38        if (!isAlive()) {
39            return null;
40        }
41
42        // If the thread has been started, wait until the looper has been created.
43        synchronized (this) {
44            while (isAlive() && mLooper == null) {
45                try {
46                    wait();
47                } catch (InterruptedException e) {
48                }
49            }
50        }
51        return mLooper;
52    }
53
54    @NonNull
55    public Handler getThreadHandler() {
56        if (mHandler == null) {
57            mHandler = new Handler(getLooper());
58        }
59        return mHandler;
60    }
61
62    public boolean quit() {
63        Looper looper = getLooper();
64        if (looper != null) {
65            looper.quit();
66            return true;
67        }
68        return false;
69    }
70
71    public boolean quitSafely() {
72        Looper looper = getLooper();
73        if (looper != null) {
74            looper.quitSafely();
75            return true;
76        }
77        return false;
78    }
79
80    public int getThreadId() {
81        return mTid;
82    }
83}

IntentService
IntentService是一种特殊的Service，它继承了Service并且它是一个抽象类，因此必须创建它的子类才能使用IntentService
IntentService可用于执行后台耗时的任务，当任务执行后它会自动停止，同事由于IntentService是服务的原因，这导致它的优先级比单纯的线程要高很多，所以IntentService比较适合执行一些高级优先级的后台任务，因为它的优先级高不容易被系统杀死。
在实现上，IntentService封装了HandlerThread和Handler，这一点可以从它的onCreate方法中看出来。

1public abstract class IntentService extends Service {
2    private volatile Looper mServiceLooper;
3    private volatile ServiceHandler mServiceHandler;
4    private String mName;
5    private boolean mRedelivery;
6
7    private final class ServiceHandler extends Handler {
8        public ServiceHandler(Looper looper) {
9            super(looper);
10        }
11
12        @Override
13        public void handleMessage(Message msg) {
14            onHandleIntent((Intent)msg.obj);
15            stopSelf(msg.arg1);
16        }
17    }
18
19    public IntentService(String name) {
20        super();
21        mName = name;
22    }
23
24    public void setIntentRedelivery(boolean enabled) {
25        mRedelivery = enabled;
26    }
27
28    @Override
29    public void onCreate() {
30        // TODO: It would be nice to have an option to hold a partial wakelock
31        // during processing, and to have a static startService(Context, Intent)
32        // method that would launch the service & hand off a wakelock.
33
34        super.onCreate();
35        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
36        thread.start();
37
38        mServiceLooper = thread.getLooper();
39        mServiceHandler = new ServiceHandler(mServiceLooper);
40    }
41
42    @Override
43    public void onStart(@Nullable Intent intent, int startId) {
44        Message msg = mServiceHandler.obtainMessage();
45        msg.arg1 = startId;
46        msg.obj = intent;
47        mServiceHandler.sendMessage(msg);
48    }
49
50    @Override
51    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
52        onStart(intent, startId);
53        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
54    }
55
56    @Override
57    public void onDestroy() {
58        mServiceLooper.quit();
59    }
60
61    @Override
62    @Nullable
63    public IBinder onBind(Intent intent) {
64        return null;
65    }
66
67    @WorkerThread
68    protected abstract void onHandleIntent(@Nullable Intent intent);
69}

使用：

1class IntentServiceDemo : IntentService("IntentServiceDemo") {
2    private val TAG = "zmm"
3
4    /* (non-Javadoc)
5     * @see android.app.IntentService#onCreate()
6     */
7    override fun onCreate() {
8        Log.e(TAG, "=>onCreate")
9        super.onCreate()
10    }
11
12    override fun onStartCommand(@Nullable intent: Intent?, flags: Int, startId: Int): Int {
13        Log.e(TAG, "=>onStartCommand")
14        return super.onStartCommand(intent, flags, startId)
15    }
16
17    /* (non-Javadoc)
18         * @see android.app.IntentService#onDestroy()
19         */
20    override fun onDestroy() {
21        Log.e(TAG, "=>onDestroy")
22        super.onDestroy()
23    }
24
25    override fun onHandleIntent(arg0: Intent?) {
26        try {
27            Log.e(TAG, "IntentService 线程：" + Thread.currentThread().id)
28            Thread.sleep(2000)
29        } catch (e: InterruptedException) {
30            e.printStackTrace()
31        }
32
33    }
34}
35
36var mServiceIntent = Intent(this@MainActivity, IntentServiceDemo::class.java)
37        startService(mServiceIntent)