原文地址: https://blog.nikitaog.me/2014/10/11/android-looper-handler-handlerthread-i/
当有人问你在Android中thread是怎样使用的？你可能会说“我用过AsyncTask在后台处理异步任务”。很好，还有其他的吗？啊，我还听说过Handler，因为我使用Handler来展示toast，或者执行延迟任务。很不错，但是我在下文将介绍一个新的框架。
从我们熟悉的AsyncTask类开始，我相信每个Android开发者都遇到过它。首先，我们可以从官方文档得到AsyncTask的一个很好的介绍。如果你不想浪费精力去学习如何管理Android threads，那么用AsyncTask来执行后台任务将是一个不错的选择。比较重要的一点你应该了解，那就是AsyncTask中只有doInBackground（）方法运行在非UI线程，其他方法都运行在UI线程。这儿有一个AsyncTask的使用例子：
//MyActivity.java
public class MyActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
MyAsyncTask myTask = new MyAsyncTask(this);
myTask.execute("http://developer.android.com");
}
}
//MyAsyncTask.java
public class MyAsyncTask extends AsyncTask<String, Void, Integer> {
private Context mContext;
public MyAsyncTask(Context context) {
mContext = context.getApplicationContext();
}
@Override
protected void onPreExecute() {
Toast.makeText(mContext, "Let's start!", Toast.LENGTH_LONG).show();
}
@Override
protected Integer doInBackground(String... params) {
HttpURLConnection connection;
try {
connection = (HttpURLConnection) new URL(params[0])
.openConnection();
return connection.getResponseCode();
} catch (IOException e) {
e.printStackTrace();
}
return -1;
}
@Override
protected void onPostExecute(Integer integer) {
if (integer != -1) {
Toast.makeText(mContext, "Got the following code: " + integer,
Toast.LENGTH_LONG).show();
}
}
}
接下来我们在main布局文件中放一个ProgressBar用来运行我们的demo：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:gravity="center">
<ProgressBar
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/progressBar"/>
</LinearLayout>
从服务端得到状态响应码是一个耗时操作，在这期间我们不想阻塞UI线程，所以我们在这里使用AsyncTask。当然使用AsyncTask有很多缺点（如果AsyncTask是一个Activity/Fragment的内部类，那么它持有外部类的一个隐式对象，这种是不好的。为什么呢？因为Activity/Fragment在configuration change的时候会被销毁，但是AsyncTask存活的时候，他们仍然会被保留在内存中。如果AsyncTask被声明为独立的或者静态内部类，然后使用Context的引用去更新UI，更新UI前我们应该检查Context是否为空）。AsyncTask是一个一次性任务，同一个AsyncTask对象，不能通过重新调用execute来让任务重新运行，应该重新创建一个AsyncTask对象。
有意思的是如果你试图在doInBackground()方法中显示一个toast，程序会报下面的错：
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:121)
at android.widget.Toast$TN.<init>(Toast.java:322)
at android.widget.Toast.<init>(Toast.java:91)
at android.widget.Toast.makeText(Toast.java:238)
at com.example.testapp.MyActivity$MyAsyncTask.doInBackground(MyActivity.java:25)
at com.example.testapp.MyActivity$MyAsyncTask.doInBackground(MyActivity.java:21)
为什么会有这个错误呢？说的简单点，因为Toast仅仅能再UI线程中展示。说的准确点，因为Toast能在拥有Looper的线程中展示。你可能会问了“什么是Looper啊？”好了，是时候刨根问底了。AsyncTask是一个不错的类，但是如果它不能够满足你的需求呢？如果我们深入研究AsyncTask的实现，就会发现，AsyncTask包含了Handler，Runnable，Thread。我们都清楚Java中的thread，但是在Android中，你会发现继承Thread的另一个类HandlerThread。HandlerThread和Thread唯一比较大的区别是，HandlerThread包含Looper，Thread以及MessageQueue。Looper对当前线程提供了一个MessageQueue。那么什么是MessageQueue呢？MessageQueue是一个包含将要执行任务的队列。Looper遍历这个队列，然后发送Message到对应的handler来处理。任何thread有一个独一无二的Looper，ThreadLocal帮我们做到了这一点。
**你可能会问了，如果task都被Handler处理，为什么要设计这么复杂？
至少有两点优势：
- 正如之前提到的，当同时好几个线程工作时，如果我们想要顺序依次执行，HandlerThread帮助我们避免了资源竞争。
- 当Thread中任务结束后，Thread是不能被重用的，但是因为Looper的存在，包含Looper的线程被保存了活动状态，直到你调用了quit方法。所以每次你想运行一个后台任务的时候，你不需要创建一个新的实例对象。**
你也可以自己创建一个带Looper的Thread，但是我推荐你使用HandlerThread。HandlerThread自带Looper，并且一些初始化的工作都为你做好了。那么什么是Handler呢？Handler包含两个基本功能：post任务到MessageQueue并且执行它们。Handler通过Looper默认与thread关联，但是你也可以在构造函数中提供Looper，用来关联Handler到其他Thread。下面来看一个实际的例子，设想一下我们有一个Activity，我们想post任务到MessageQueue，这些任务被延迟执行。
public class MyActivity extends Activity {
private Handler mUiHandler = new Handler();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Thread myThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 4; i++) {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (i == 2) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
Toast.makeText(MyActivity.this,
"I am at the middle of background task",
Toast.LENGTH_LONG)
.show();
}
});
}
}
mUiHandler.post(new Runnable() {
@Override
public void run() {
Toast.makeText(MyActivity.this,
"Background task is completed",
Toast.LENGTH_LONG)
.show();
}
});
}
});
myThread.start();
}
}
由于mUiHandler与UI线程相关联（Handler在默认构造函数中，得到UI线程的Looper），mUiHandler是一个类成员，我们通过匿名内部类来使用它，所以可以post任务到UI线程。在上面的例子中，我们使用Thread，如果我们要post一个新的任务，我们不能重新使用这个Thread实例，我们必须创建一个新的Thread对象。那么有其他办法吗？当然。我们可以使用带Looper的Thread。下面有一个简单的例子，不同的是我们使用了HandlerThread而不是Thread，优点就是Thread可以被重复执行：
//MyActivity.java
public class MyActivity extends Activity {
private Handler mUiHandler = new Handler();
private MyWorkerThread mWorkerThread;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mWorkerThread = new MyWorkerThread("myWorkerThread");
Runnable task = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 4; i++) {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (i == 2) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
Toast.makeText(MyActivity.this,
"I am at the middle of background task",
Toast.LENGTH_LONG)
.show();
}
});
}
}
mUiHandler.post(new Runnable() {
@Override
public void run() {
Toast.makeText(MyActivity.this,
"Background task is completed",
Toast.LENGTH_LONG)
.show();
}
});
}
};
mWorkerThread.start();
mWorkerThread.prepareHandler();
mWorkerThread.postTask(task);
mWorkerThread.postTask(task);
}
@Override
protected void onDestroy() {
mWorkerThread.quit();
super.onDestroy();
}
}
//MyWorkerThread.java
public class MyWorkerThread extends HandlerThread {
private Handler mWorkerHandler;
public MyWorkerThread(String name) {
super(name);
}
public void postTask(Runnable task){
mWorkerHandler.post(task);
}
public void prepareHandler(){
mWorkerHandler = new Handler(getLooper());
}
}
在这个例子中，我使用了HandlerThread，因为我不想自己去管理Looper，HandlerThread已经帮我们实现了它。一旦我们开始了HandlerThread，在任何时间我们可以post任务，当你想停止HandlerThread的时候别忘了调用quit方法。mWorkerHandler通过myWorkerThread的Looper与myWorkerThread相绑定。你不能在HandlerThread构造函数中初始化mWorkerHandler，因为在thread不是活动状态的时候getLooper会返回null。你或许会发现下面这种handler的初始化方式：
private class MyWorkerThread extends HandlerThread {
private Handler mWorkerHandler;
public MyWorkerThread(String name) {
super(name);
}
@Override
protected void onLooperPrepared() {
mWorkerHandler = new Handler(getLooper());
}
public void postTask(Runnable task){
mWorkerHandler.post(task);
}
}
有时它会起作用，有时在调用postTask的时候，会出现NullPointerException，mWorkerHandler为null。卧槽？
[站外图片上传中...(image-19d4aa-1531388491240)]
为什么呢？那是因为在新线程创建的时候需要native调用。如果我们看onLooperPrepared被调用的代码，就会在HandlerThread中发现如下的代码片段：
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
仅仅在新线程被创建并且启动的情况下才会run方法才会被调用。出现NullPointerException异常的原因在于，run（）方法在postTask（）之后调用。所以就是被两个线程（主线程和后台线程）之间的竞争条件害惨了。
