Android多线程（三）

　　上次讲了关于Android多线程中通信中Thread、Handler、Looper等的基础概念和基本用法，用现实世界两个人写信交流的过程来理解是再好不过了。但是不得不说这一套完整的细节的确很繁琐，好在Android中为我们提供了另一个简化的API——HandlerThread，通过使用HandlerThread，我们可以以一种简单的方式开启线程、进行线程通信。Let's do it!

三、HandlerThread

　　1)参考文档：http://developer.android.com/reference/android/os/HandlerThread.html

　　前面的连篇文章中我都贴出来相应内容的官方文档地址，也斗胆说了一下读文档的重要性。这次我们换一种方式——读源代码，好的代码本身就是一份文档，除了会写还得能读！如何找到Android的源码？不管你用的是不再更新的ADT+Eclipse还是AS（Android studio），你的电脑里一定得下载sdk，在sdk目录下有个叫sources的文件夹，里面放的就是Android的系统源码。（开源大法好！）如果你没有，那就“翻墙”下一份，如何快速更新sdk我会在下一篇博客里写......

　　2）HandlerThread源码：

　　我在这把源码贴出来方便查看（我电脑上的源码是Android-22的）

package android.os;

/**
 * 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 {
    //线程的优先级
    int mPriority;

    //线程id
    int mTid = -1;

    //与线程绑定的Looper对象
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }

    /**
     * Constructs a HandlerThread.
     * @param name
     * @param priority The priority to run the thread at. The value supplied must be from
     * {@link android.os.Process} and not from java.lang.Thread.
     */
    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.
     * 这里是你需要实现的部分，你的在这里实现对Handler的准备工作，定义你的Hadnler并实现
     *handlerMessage(Message msg)方法。
     */
    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 is 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;
    }

    /**
     * Quits the handler thread's looper.
     * <p>
     * Causes the handler thread's looper to terminate without processing any
     * more messages in the message queue.
     * </p><p>
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
     * For example, the {@link Handler#sendMessage(Message)} method will return false.
     * </p><p class="note">
     * Using this method may be unsafe because some messages may not be delivered
     * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
     * that all pending work is completed in an orderly manner.
     * </p>
     *
     * @return True if the looper looper has been asked to quit or false if the
     * thread had not yet started running.
     *
     * @see #quitSafely
     */
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

    /**
     * Quits the handler thread's looper safely.
     * <p>
     * Causes the handler thread's looper to terminate as soon as all remaining messages
     * in the message queue that are already due to be delivered have been handled.
     * Pending delayed messages with due times in the future will not be delivered.
     * </p><p>
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
     * For example, the {@link Handler#sendMessage(Message)} method will return false.
     * </p><p>
     * If the thread has not been started or has finished (that is if
     * {@link #getLooper} returns null), then false is returned.
     * Otherwise the looper is asked to quit and true is returned.
     * </p>
     *
     * @return True if the looper looper has been asked to quit or false if the
     * thread had not yet started running.
     */
    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;
    }
}

　　这里我们重点看两个方法：

 　　protected void onLooperPrepared() 这是一个在拓展类中需要重写的方法，它完成准备工作，一般是对Handelr进行定义。比如接受到主线程发来的消息时如何做出应对。在后面的示例中我就会对Handler进行定义，在handleMessage(Message msg)中定义行为。

　　public void run() 再看这个方法里的内容是不是感到很熟悉，理解了Thread、Handler、Looper等概念后，是不是很容易就读懂了它的意思。对了，拓展HandlerThread时，如果要override run方法一定要记得调用父类的run（） 。

　　对于其他的方法，在这里就不赘述了，每个方法的前面的注释就详细说明了它们的作用。

　　3）一个简单的示例：

　　还是一样的，我用一个示例来说明HandlerThread的用法。还是一样的开启线程，等到接收到主线程发来的消息，然后打印打印日志。

布局：

  <TextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_centerHorizontal="true"
         android:text="HandlerThread"/>

     <Button
         android:id="@+id/button"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_alignParentBottom="true"
         android:text="send message"/>

拓展的HandlerThread类：

 public class MyThread extends HandlerThread {

     private static final String TAG = "MyThread";
     private Handler mHandler;

     public MyThread() {
         super(TAG);
     }

     @Override
     protected void onLooperPrepared() {
         super.onLooperPrepared();
         mHandler = new Handler(){
             @Override
             public void handleMessage(Message msg) {
                 super.handleMessage(msg);
                 if(msg.what == MainActivity.MSG_MAIN){
                     handlerRequest(msg.obj);
                 }
             }
         };
         return;
     }

     private void handlerRequest(Object obj){
         Log.d(TAG, "handlerRequest:" + obj + ",thread:" + Thread.currentThread().getName());
         Looper looper = Looper.getMainLooper();
         Handler handler = new Handler(looper);
         handler.post(new Runnable() {
             @Override
             public void run() {
                 Log.d(TAG,"message is handled，thread："+Thread.currentThread().getName());
                 return;
             }
         });
         return;
     }

     public Handler getHandler() {
         return mHandler;
     }
 }

这次我使用了post方法很主线程进行通信。

Activity代码：

 public class MainActivity extends AppCompatActivity {

     public static final int MSG_MAIN = 100;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);

         final MyThread thread = new MyThread();
         thread.start();
         thread.getLooper();

         final Button sendButton = (Button) findViewById(R.id.button);
         sendButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View view) {
                 Handler handler = thread.getHandler();
                 Message msg = handler.obtainMessage();
                 msg.what = MainActivity.MSG_MAIN;
                 msg.obj="testing HandlerThread";
                 handler.sendMessage(msg);
                 return;
             }
         });
     }
 }

　　Logcat打印日志：

　　10-08 11:45:47.152 13949-14004/comfallblank.github.handlerthread D/MyThread: handlerRequest:testing HandlerThread,thread:MyThread
　　10-08 11:45:47.162 13949-13949/comfallblank.github.handlerthread D/MyThread: message is handled，thread：main

　　这次我在日志中加入了线程名称，这样就可以看出任务执行的线程了。

　　到这里，关于Android线程的内容算写完了，本来打算在国庆期间写完了，最后拖拖拉拉延迟了一天。还有国庆长假后第一天上课好累啊！就这样吧！下一篇关于如何快速更新sdk努力在这周写出来。

最后，欢迎大家交流，指正我不正确的地方。

邮箱：fallblank525@gmail.com　　QQ:1054746297