1、基础使用
public class DemoActivity extends AppCompatActivity {
private static final String TAG = "DemoActivity";
private WorkHandler workHandler;
private Button sendMsgDiffBt;
@Override
protected void onCreate(@Nullable @org.jetbrains.annotations.Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_demo);
HandlerThread workThread = new HandlerThread("SessionManager$1");
workThread.start();
workHandler = new WorkHandler(workThread.getLooper(),this);
sendMsgDiffBt = findViewById(R.id.bt_send_msg_diff);
sendMsgDiffBt.setOnClickListener(view -> {
workHandler.sendEmptyMessage(1);
});
}
static class WorkHandler extends Handler {
private WeakReference<AppCompatActivity> activityWeakReference = null;
public WorkHandler(Looper looper, AppCompatActivity appCompatActivity) {
super(looper);
activityWeakReference = new WeakReference<>(appCompatActivity);
}
@Override
public void handleMessage(Message msg) {
int what = msg.what;
Log.i(TAG, "handleMessage: " + Looper.getMainLooper().getThread().getName());
Log.i(TAG, "handleMessage: " + Looper.myLooper().getThread().getName());
Log.i(TAG, "thread:" + Thread.currentThread().getId() + "," + Thread.currentThread().getName());
}
}
}
以上是一个Demo标准的写法,没有业务逻辑,我们来看一一下他的输出
根据控制台的输出handleMessage的消息我们可以看出来,,主线程是main线程,而当前线程是我们自定义名字的线程,所以我们可以去猜测他就是一个线程,由于没有证据去支持这个猜测,我们需要去看源码,去证实这个猜测;
2、源码解析
源码不多我们就将他的所有都展示出来,注释我就转换成中文了,方便我们我们去解析它了
package android.os;
import android.annotation.NonNull;
import android.annotation.Nullable;
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
private @Nullable
Handler mHandler;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
/**
* Constructs a HandlerThread.
* @param name 名称
* @param priority 优先级 越大优先级越高
* {@link android.os.Process} and not from java.lang.Thread.
*/
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;
}
/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason isAlive() returns false, this method will return null. If this thread
* has been started, this method will block until the looper has been initialized.
* @return The looper.
*/
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;
}
/**
* @return 获取当前Handler
* @hide
*/
@NonNull
public Handler getThreadHandler() {
if (mHandler == null) {
mHandler = new Handler(getLooper());
}
return mHandler;
}
/**
* 非安全的退出处理程序线程的循环器
* @see #quitSafely
*/
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
/**
* 安全的退出处理程序线程的循环器
* @see #quitSafely
*/
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
/**
* Returns the identifier of this thread. See Process.myTid().
*/
public int getThreadId() {
return mTid;
}
}
总结一下:从源码当中我们首先可以看出来在android包下,他是系统提供,其次可看到HandlerThread 继承的就是一个Thread ,通过对Looper的操作进行分装的一个帮助类,如果对Looper不熟悉的,可以去了解一下Handler的消息机制,这个就不多说这个了,了解其原理那我们是不是也可以封装一个我们自己的HandlerThread,哈哈。那根据它的业务逻辑我们是不是可以应用到我们的应用场景了,比如单线程任务当中,这个看业务需求,不是必须的拉。