Merge pull request LRH1993#28 from Notzuonotdied/master

调整了文章的编辑细节。

Author: LRH1993

android/basis/HandlerThread.md

@@ -1,4 +1,4 @@
-**我们知道在Android系统中，我们执行完耗时操作都要另外开启子线程来执行，执行完线程以后线程会自动销毁。想象一下如果我们在项目中经常要执行耗时操作，如果经常要开启线程，接着又销毁线程，这无疑是很消耗性能的?那有什么解决方法呢？**
+**我们知道在Android系统中，我们执行完耗时操作都要另外开启子线程来执行，执行完线程以后线程会自动销毁。想象一下如果我们在项目中经常要执行耗时操作，如果经常要开启线程，接着又销毁线程，这无疑是很消耗性能的？那有什么解决方法呢？**
 
 1. 使用线程池
 2. 使用HandlerThread
@@ -12,7 +12,7 @@
 
 ### 使用场景
 
-HandlerThread是Google帮我们封装好的，可以用来执行多个耗时操作，而不需要多次开启线程，里面是采用handler和Looper实现的
+HandlerThread是Google帮我们封装好的，可以用来执行多个耗时操作，而不需要多次开启线程，里面是采用Handler和Looper实现的。
 
 > 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.
 
@@ -35,7 +35,7 @@ handlerThread.start();
 1. 将我们的handlerThread与Handler绑定在一起。 
    还记得是怎样将Handler与线程对象绑定在一起的吗？其实很简单，就是将线程的looper与Handler绑定在一起，代码如下：
 
-```java
+``` java
 mThreadHandler = new Handler(mHandlerThread.getLooper()) {
     @Override
     public void handleMessage(Message msg) {
@@ -51,34 +51,37 @@ mThreadHandler = new Handler(mHandlerThread.getLooper()) {
 
 ### 完整测试代码如下
 
-```java
+``` java
 public class MainActivity extends AppCompatActivity {
-    private TextView mTv;
+    private static final int MSG_UPDATE_INFO = 0x100;
     Handler mMainHandler = new Handler();
+    private TextView mTv;
     private Handler mThreadHandler;
-    private static final int MSG_UPDATE_INFO = 0x100;
     private HandlerThread mHandlerThread;
-    private boolean isUpdate=true;
+    private boolean isUpdate = true;
+
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         mTv = (TextView) findViewById(R.id.tv);
         initHandlerThread();
     }
+
     private void initHandlerThread() {
         mHandlerThread = new HandlerThread("xujun");
         mHandlerThread.start();
         mThreadHandler = new Handler(mHandlerThread.getLooper()) {
             @Override
             public void handleMessage(Message msg) {
                 checkForUpdate();
-                if(isUpdate){
+                if (isUpdate) {
                     mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
                 }
             }
         };
     }
+
     /**
      * 模拟从服务器解析数据
      */
@@ -98,18 +101,21 @@ public class MainActivity extends AppCompatActivity {
             e.printStackTrace();
         }
     }
+
     @Override
     protected void onResume() {
-        isUpdate=true;
+        isUpdate = true;
         super.onResume();
         mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
     }
+
     @Override
     protected void onPause() {
         super.onPause();
-        isUpdate=false;
+        isUpdate = false;
         mThreadHandler.removeMessages(MSG_UPDATE_INFO);
     }
+
     @Override
     protected void onDestroy() {
         super.onDestroy();
@@ -127,27 +133,31 @@ public class MainActivity extends AppCompatActivity {
 
 ## HandlerThread源码分析
 
-官方源代码如下，是基于sdk23的，可以看到，只有一百多行代码而已
+官方源代码如下，是基于sdk23的，可以看到，只有一百多行代码而已。
 
 ```java
 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;
     }
+
     /**
      * Call back method that can be explicitly overridden if needed to execute some
      * setup before Looper loops.
      */
     protected void onLooperPrepared() {
     }
+
     @Override
     public void run() {
         mTid = Process.myTid();
@@ -165,6 +175,7 @@ public class HandlerThread extends Thread {
         Looper.loop();
         mTid = -1;
     }
+
     public Looper getLooper() {
         if (!isAlive()) {
             return null;
@@ -180,6 +191,7 @@ public class HandlerThread extends Thread {
         }
         return mLooper;
     }
+
     public boolean quit() {
         Looper looper = getLooper();
         if (looper != null) {
@@ -188,6 +200,7 @@ public class HandlerThread extends Thread {
         }
         return false;
     }
+
     public boolean quitSafely() {
         Looper looper = getLooper();
         if (looper != null) {
@@ -196,6 +209,7 @@ public class HandlerThread extends Thread {
         }
         return false;
     }
+
     /**
      * Returns the identifier of this thread. See Process.myTid().
      */
@@ -208,19 +222,20 @@ public class HandlerThread extends Thread {
 ### 1）首先我们先来看一下它的构造方法
 
 ```java
- public HandlerThread(String name) {
-        super(name);
-        mPriority = Process.THREAD_PRIORITY_DEFAULT;
-    }
-    public HandlerThread(String name, int priority) {
-        super(name);
-        mPriority = priority;
-    }
+public HandlerThread(String name) {
+    super(name);
+    mPriority = Process.THREAD_PRIORITY_DEFAULT;
+}
+
+public HandlerThread(String name, int priority) {
+    super(name);
+    mPriority = priority;
+}
 ```
 
 有两个构造方法，一个参数的和两个参数的，name代表当前线程的名称，priority为线程的优先级别
 
-### 2）接着我们来看一下run（）方法，在run方法里面我们可以看到我们会初始化一个Looper，并设置线程的优先级别
+### 2）接着我们来看一下run()方法，在run方法里面我们可以看到我们会初始化一个Looper，并设置线程的优先级别
 
 ```java
 public void run() {
@@ -241,7 +256,7 @@ public void run() {
 }
 ```
 
-- 还记得我们前面我们说到使用HandlerThread的时候必须调用start（）方法，接着才可以将我们的HandlerThread和我们的handler绑定在一起吗?其实原因就是我们是在run（）方法才开始初始化我们的looper，而我们调用HandlerThread的start（）方法的时候，线程会交给虚拟机调度，由虚拟机自动调用run方法
+- 还记得我们前面我们说到使用HandlerThread的时候必须调用`start()`方法，接着才可以将我们的HandlerThread和我们的handler绑定在一起吗?其实原因就是我们是在`run()`方法才开始初始化我们的looper，而我们调用HandlerThread的`start()`方法的时候，线程会交给虚拟机调度，由虚拟机自动调用run方法：
 
 ```java
 mHandlerThread.start();
@@ -256,7 +271,7 @@ mThreadHandler = new Handler(mHandlerThread.getLooper()) {
 };
 ```
 
-- 这里我们为什么要使用锁机制和notifyAll();，原因我们可以从getLooper（）方法中知道
+- 这里我们为什么要使用锁机制和`notifyAll()`;，原因我们可以从`getLooper()`方法中知道
 
 ```java
 public Looper getLooper() {
@@ -302,7 +317,7 @@ public boolean quitSafely() {
 }
 ```
 
-跟踪这两个方法容易知道只两个方法最终都会调用MessageQueue的quit（boolean safe）方法
+跟踪这两个方法容易知道只两个方法最终都会调用MessageQueue的`quit(boolean safe)`方法
 
 ```java
 void quit(boolean safe) {
@@ -326,7 +341,7 @@ void quit(boolean safe) {
 }
 ```
 
-不安全的会调用removeAllMessagesLocked();这个方法，我们来看这个方法是怎样处理的，其实就是遍历Message链表，移除所有信息的回调，并重置为null
+不安全的会调用`removeAllMessagesLocked();`这个方法，我们来看这个方法是怎样处理的，其实就是遍历Message链表，移除所有信息的回调，并重置为null。
 
 ```java
 private void removeAllMessagesLocked() {
@@ -340,14 +355,14 @@ private void removeAllMessagesLocked() {
 }
 ```
 
-安全地会调用removeAllFutureMessagesLocked();这个方法，它会根据Message.when这个属性，判断我们当前消息队列是否正在处理消息，没有正在处理消息的话，直接移除所有回调，正在处理的话，等待该消息处理处理完毕再退出该循环。因此说quitSafe（）是安全的，而quit（）方法是不安全的，因为quit方法不管是否正在处理消息，直接移除所有回调。
+安全地会调用`removeAllFutureMessagesLocked();`这个方法，它会根据Message.when这个属性，判断我们当前消息队列是否正在处理消息，没有正在处理消息的话，直接移除所有回调，正在处理的话，等待该消息处理处理完毕再退出该循环。因此说`quitSafe()`是安全的，而`quit()`方法是不安全的，因为quit方法不管是否正在处理消息，直接移除所有回调。
 
 ```java
 private void removeAllFutureMessagesLocked() {
     final long now = SystemClock.uptimeMillis();
     Message p = mMessages;
     if (p != null) {
-        //判断当前队列中的消息是否正在处理这个消息，》没有的话，直接移除所有回调
+        //判断当前队列中的消息是否正在处理这个消息，没有的话，直接移除所有回调
         if (p.when > now) {
             removeAllMessagesLocked();
         } else {//正在处理的话，等待该消息处理处理完毕再退出该循环