HandlerThread - 基本使用以及原理解析

本篇主要探讨以下主要内容,可根据需要,选择按顺序读或者跳读。

HandlerThread部分源码

/**
 * Handy class for starting a new thread that has a looper. The looper can then be 
 * used to create handler classes. Note that start() must still be called.
 */
public class HandlerThread extends Thread {
    
    Looper mLooper;
    private @Nullable Handler mHandler;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    ...省略部分代码
   @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
		Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    ...省略部分代码

什么是HandlerThread?

正如源码中,类注释所述,一个拥有Looper的灵活线程,可以使用这个Looper来创建一个Handler.同常规线程一样,Thread.start()仍必须调用。

如果获取Looper?

通过(HandlerThread对象).getLooper()即可获取当前HandlerThread线程中关联的Looper.

如何退出或关闭HandlerThread?

使用(HandlerThread对象).quit()或(HandlerThread对象).quitSafely()退出。

Demo示例-如何使用HandlerThread？

Demo代码如下:

public class MainActivity extends AppCompatActivity {

    private static final String TAG = MainActivity.class.getSimpleName();
    private static final int HANDLER_THREAD_TASK_NO_1 = 1;
    //工作线程
    private HandlerThread mWorkThread;
    //通过HandlerThread中的Looper创建的Handler.
    private Handler mWorkHandler;
    private View mBtSendTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mBtSendTask = findViewById(R.id.bt_send_task);


        mBtSendTask.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Message message  = new Message();
                message.what = HANDLER_THREAD_TASK_NO_1;
                Bundle bundle = new Bundle();
                bundle.putString("account_id","123");
                bundle.putString("name","mike");
                message.setData(bundle);
                mWorkHandler.sendMessage(message);
            }
        });

        mWorkThread = new HandlerThread("work-Thread");

        //同普通的线程一样,必须调用start,让run方法运行起来,初始化Handler.
        mWorkThread.start();

        //使用工作线程中的Looper(HandlerThread中的)来构建一个Handler
        mWorkHandler = new Handler(mWorkThread.getLooper()){
            /*
             *  由于我们Handler的Looper是从HandlerThread中获取到的,所以handleMessage会在子线中执行。
             *  我们可以通过传递的Message中来获取相关参数,并执行异步任务。
             * */
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
                Log.e(TAG,"当前线程Name: "+Thread.currentThread().getName()); //E/MainActivity: 当前线程Name: work-Thread

                switch (msg.what) {
                    case HANDLER_THREAD_TASK_NO_1:

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

                        Bundle data = msg.getData();
                        String account_id = data.getString("account_id");
                        String name = data.getString("name");
                        Log.e(TAG,"account: " + account_id + " name: "+name);
                        break;
                }
            }
        };
    }

    @Override
    protected void onDestroy() {
        //使用完成后,关闭线程
        mWorkThread.quit();
        //清除handler中的消息
        mWorkHandler.removeCallbacksAndMessages(null);
        super.onDestroy();
    }
}

HandlerThread使用于哪些场景？

目前想到的是:有很多任务要处理,但任务必须异步并按顺序处理的情况。

理由:Handler和Thread的结合,提供了异步处理和任务消息队列,可以很好的对任务进行排队。

IntentService - 源码中的HandlerThread使用

IntentService,一种特殊的Service;可以处理异步耗时任务,执行完毕,自动关闭。

普通Service是在主UI线程线程执行,如果我们需要进行耗时操作,则必须通过 new Thread()来开启一个线程来做耗时任务。

来看IntentService的源码部分:

public abstract class IntentService extends Service {

    //HandlerThread中的Looper
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;

    //声明一个类,ServiceHandler继承自Handler
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        /*
          如果我们使用IntentService,要关注的只有onHandleIntent,因为它执行在子线程(工作线程)
          可以看到这里在调用完onHandleIntent后,即调用了 stopSelf().
          那么我们重点需要关注的即是handleMessage所处的线程。
        */
        @Override
        public void handleMessage(Message msg) {
            //收到传递的消息,进行耗时任务
            onHandleIntent((Intent)msg.obj);
            //任务结束后关闭服务
            stopSelf(msg.arg1);
        }
    }

    //...省略代码

    @Override
    public void onCreate() {
        super.onCreate();
        //这里创建了一个HandlerThread,并调用了start()
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        //获取了HandlerThread中的 Looper()
        mServiceLooper = thread.getLooper();
        //将获取到的Looper()用来创建ServiceHandler,那么ServiceHandler即允许在Looper所在的线程
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        //将我们传递的消息,发送到队列里,等待传递
        mServiceHandler.sendMessage(msg);
    }

    //...省略代码
}

可以看到IntentService中的代码还是比较清晰的。步骤:

1.创建HandlerThread,并调用start().
2.获取HandlerThread中的Looper,创建任务处理的ServiceHandler,并重写handleMessage().
3.外部启动服务,onStart()中获取Intent中的数据,并构建Message对象,通过2中创建的ServiceHandler发送消息。
4.通过HandlerThread中run()方法的Looper轮询处理消息,调用ServiceHandler的handleMessage().
5.我们在onHandleIntent()进行耗时任务。结束后,服务自动关闭。

程序小白,偶尔写写,知识探究与记录,有误之处,望不吝赐教。