Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Android 多線程之HandlerThread 完全詳解

Android 多線程之HandlerThread 完全詳解

編輯：關於Android編程

之前對線程也寫過幾篇文章，不過倒是沒有針對android，因為java與android在線程方面大部分還是相同，不過本篇我們要介紹的是android的專屬類HandlerThread，因為HandlerThread在設置思想上還是挺值得我們學習的，那麼我們下面來就了解它吧，我們先來看看HandlerThread有那些特點：

HandlerThread本質上是一個線程類，它繼承了Thread； HandlerThread有自己的內部Looper對象，可以進行looper循環； 通過獲取HandlerThread的looper對象傳遞給Handler對象，可以在handleMessage方法中執行異步任務。 創建HandlerThread後必須先調用HandlerThread.start()方法，Thread會先調用run方法，創建Looper對象。

一、HandlerThread常規使用步驟

了解完上面HandlerThread的一些特點後，我們先來看看HandlerThread使用步驟。
1.創建實例對象

    1.  HandlerThread handlerThread = new HandlerThread("downloadImage");

傳入參數的作用主要是標記當前線程的名字，可以任意字符串。
2.啟動HandlerThread線程

    1.  //必須先開啟線程
    2.  handlerThread.start();

??到此，我們創建完HandlerThread並啟動了線程。那麼我們怎麼將一個耗時的異步任務投放到HandlerThread線程中去執行呢？接下來看下面步驟：
3.構建循環消息處理機制

  /**
     * 該callback運行於子線程
     */
    class ChildCallback implements Handler.Callback {
        @Override
        public boolean handleMessage(Message msg) {
            //在子線程中進行相應的網絡請求

            //通知主線程去更新UI
            mUIHandler.sendMessage(msg1);
            return false;
        }
    }

4.構建異步handler

//子線程Handler
Handler childHandler = new Handler(handlerThread.getLooper(),new ChildCallback());

??第3步和第4步是構建一個可以用於異步操作的handler，並將前面創建的HandlerThread的Looper對象以及Callback接口類作為參數傳遞給當前的handler，這樣當前的異步handler就擁有了HandlerThread的Looper對象，由於HandlerThread本身是異步線程，因此Looper也與異步線程綁定，從而handlerMessage方法也就可以異步處理耗時任務了，這樣我們的Looper+Handler+MessageQueue+Thread異步循環機制構建完成，來看看一個完整的使用案例。

二、HandlerThread的使用案例

主要代碼如下：
activity_handler_thread.xml

HandlerThreadActivity.java

package com.zejian.handlerlooper;
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.widget.ImageView;
import com.zejian.handlerlooper.model.ImageModel;
import com.zejian.handlerlooper.util.LogUtils;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
/**
 * Created by zejian on 16/9/2.
 */
public class HandlerThreadActivity extends Activity {
    /**
     * 圖片地址集合
     */
    private String url[]={
            "http://img.blog.csdn.net/20160903083245762",
            "http://img.blog.csdn.net/20160903083252184",
            "http://img.blog.csdn.net/20160903083257871",
            "http://img.blog.csdn.net/20160903083257871",
            "http://img.blog.csdn.net/20160903083311972",
            "http://img.blog.csdn.net/20160903083319668",
            "http://img.blog.csdn.net/20160903083326871"
    };
    private ImageView imageView;
    private Handler mUIHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            LogUtils.e("次數:"+msg.what);
            ImageModel model = (ImageModel) msg.obj;
            imageView.setImageBitmap(model.bitmap);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);
        imageView= (ImageView) findViewById(R.id.image);
        //創建異步HandlerThread
        HandlerThread handlerThread = new HandlerThread("downloadImage");
        //必須先開啟線程
        handlerThread.start();
        //子線程Handler
        Handler childHandler = new Handler(handlerThread.getLooper(),new ChildCallback());
        for(int i=0;i<7;i++){
            //每個1秒去更新圖片
            childHandler.sendEmptyMessageDelayed(i,1000*i);
        }
    }
    /**
     * 該callback運行於子線程
     */
    class ChildCallback implements Handler.Callback {
        @Override
        public boolean handleMessage(Message msg) {
            //在子線程中進行網絡請求
            Bitmap bitmap=downloadUrlBitmap(url[msg.what]);
            ImageModel imageModel=new ImageModel();
            imageModel.bitmap=bitmap;
            imageModel.url=url[msg.what];
            Message msg1 = new Message();
            msg1.what = msg.what;
            msg1.obj =imageModel;
            //通知主線程去更新UI
            mUIHandler.sendMessage(msg1);
            return false;
        }
    }
    private Bitmap downloadUrlBitmap(String urlString) {
        HttpURLConnection urlConnection = null;
        BufferedInputStream in = null;
        Bitmap bitmap=null;
        try {
            final URL url = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
            bitmap=BitmapFactory.decodeStream(in);
        } catch (final IOException e) {
            e.printStackTrace();
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            try {
                if (in != null) {
                    in.close();
                }
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
}

??在這個案例中，我們創建了兩個Handler，一個用於更新UI線程的mUIHandler和一個用於異步下載圖片的childHandler。最終的結果是childHandler會每個隔1秒鐘通過sendEmptyMessageDelayed方法去通知ChildCallback的回調函數handleMessage方法去下載圖片並告訴mUIHandler去更新UI界面，以上便是HandlerThread常規使用，實際上在android比較典型的應用是IntentService，這個我們將放在下篇分析，這裡就先不深入了，案例運行截圖如下：
\

三.HandlerThread源碼解析

??HandlerThread的源碼不多只有140多行，那就一步一步來分析吧，先來看看其構造函數

/**
 * 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;//線程優先級
    int mTid = -1;
    Looper mLooper;//當前線程持有的Looper對象
    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.
     */
    protected void onLooperPrepared() {
    }

??從源碼可以看出HandlerThread繼續自Thread,構造函數的傳遞參數有兩個，一個是name指的是線程的名稱，一個是priority指的是線程優先級，我們根據需要調用即可。其中成員變量mLooper就是HandlerThread自己持有的Looper對象。onLooperPrepared()該方法是一個空實現，是留給我們必要時可以去重寫的，但是注意重寫時機是在Looper循環啟動前，再看看run方法：

@Override
public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll(); //喚醒等待線程
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
   }

??前面我們在HandlerThread的常規使用中分析過，在創建HandlerThread對象後必須調用其start()方法才能進行其他操作，而調用start()方法後相當於啟動了線程，也就是run方法將會被調用，而我們從run源碼中可以看出其執行了Looper.prepare()代碼，這時Looper對象將被創建，當Looper對象被創建後將綁定在當前線程（也就是當前異步線程），這樣我們才可以把Looper對象賦值給Handler對象，進而確保Handler對象中的handleMessage方法是在異步線程執行的。接著將執行代碼：

synchronized (this) {
       mLooper = Looper.myLooper();
       notifyAll(); //喚醒等待線程
   }

??這裡在Looper對象創建後將其賦值給HandlerThread的內部變量mLooper，並通過notifyAll()方法去喚醒等待線程，最後執行Looper.loop();代碼，開啟looper循環語句。那這裡為什麼要喚醒等待線程呢？我們來看看，getLooper方法

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;
}

??事實上可以看出外部在通過getLooper方法獲取looper對象時會先先判斷當前線程是否啟動了，如果線程已經啟動，那麼將會進入同步語句並判斷Looper是否為null，為null則代表Looper對象還沒有被賦值，也就是還沒被創建，此時當前調用線程進入等待階段，直到Looper對象被創建並通過 notifyAll()方法喚醒等待線程，最後才返回Looper對象，之所以需要等待喚醒機制，是因為Looper的創建是在子線程中執行的，而調用getLooper方法則是在主線程進行的，這樣我們就無法保障我們在調用getLooper方法時Looper已經被創建，到這裡我們也就明白了在獲取mLooper對象時會存在一個同步的問題，只有當線程創建成功並且Looper對象也創建成功之後才能獲得mLooper的值，HandlerThread內部則通過等待喚醒機制解決了同步問題。

public boolean quit() {  
       Looper looper = getLooper();  
       if (looper != null) {  
           looper.quit();  
           return true;  
       }  
       return false;  
   }  
public boolean quitSafely() {  
    Looper looper = getLooper();  
    if (looper != null) {  
           looper.quitSafely();  
           return true;  
       }  
       return false;  
   }

??從源碼可以看出當我們調用quit方法時，其內部實際上是調用Looper的quit方法而最終執行的則是MessageQueue中的removeAllMessagesLocked方法（Handler消息機制知識點），該方法主要是把MessageQueue消息池中所有的消息全部清空，無論是延遲消息（延遲消息是指通過sendMessageDelayed或通過postDelayed等方法發送）還是非延遲消息。
??當調用quitSafely方法時，其內部調用的是Looper的quitSafely方法而最終執行的是MessageQueue中的removeAllFutureMessagesLocked方法，該方法只會清空MessageQueue消息池中所有的延遲消息，並將消息池中所有的非延遲消息派發出去讓Handler去處理完成後才停止Looper循環，quitSafely相比於quit方法安全的原因在於清空消息之前會派發所有的非延遲消息。最後需要注意的是Looper的quit方法是基於API 1，而Looper的quitSafely方法則是基於API 18的。
好~，到此對於HandlerThread的所有分析就到此完結。

  1. 上一頁:
  2. 下一頁:
關於Android編程
Android編程入門Android技術基礎Android資訊關於Android編程Android開發Android開發環境Android開發實例
相關文章
熱門文章
Android應用UI開發中Fragment的常見用法小結 android 框架LoonAndroid，碼農偷懶專用 Android框架 與 源碼結構 android獲取照片的快照 Android 基於Netty的消息推送方案之字符串的接收和發送（三） Android布局性能優化之按需加載View
Qt for Android 編譯安卓原生可執行程序

作為 C/C++ 程序員，有時候我們希望在安卓上運行從

Android逆向分析之Xposed的hook技術

Android逆向工程裡常用到的工具除了的dex2jar，jd-gui,
android中使用jni對字符串加解密實現分析

android中使用jni對字符串加解密實現分析 最近項目有個需求，
微信語音消息怎麼轉發給別人

現在微信基本上人人都會用，也極大的方便了我們的生活各方面，
閱讀排行版
Copyright © Android教程網 All Rights Reserved