2. 程式人生 > >Android效能優化之實現擁有Looper的執行緒--HandlerThread

Android效能優化之實現擁有Looper的執行緒--HandlerThread

阿新 • • 發佈：2018-12-30

1 HandlerThread

1.1 定義

　　HandlerThread是能夠新建擁有Looper的Thread，這個Looper能夠用來新建其他的Handler。HandlerThread本質是一個執行緒，線上程內部，程式碼是序列處理的。（執行緒中的Looper）需要注意的是，新建的時候需要被回撥。

1.2 特點

（1） HandlerThread將loop轉到子執行緒中處理，目的就是分擔MainLooper的工作量，降低了主執行緒的壓力，使主介面更流暢。
（2）開啟一個執行緒起到多個執行緒的作用。處理任務是序列執行，按訊息傳送順序進行處理。
（3）但是由於每一個任務都將以佇列的方式逐個被執行到，一旦佇列中有某個任務執行時間過長，那麼就會導致後續的任務都會被延遲處理。
（4）HandlerThread擁有自己的訊息佇列，它不會干擾或阻塞UI執行緒。

1.3 應用場景

　　HandlerThread繼承自Thread，一般適應的場景，便是集Thread和Handler之所長，適用於會長時間在後臺執行，並且間隔時間內（或適當情況下）會呼叫的情況，比如上面所說的實時更新。其實使用HandlerThread的效果和使用Thread+Handler差不多。不過後者對開發者的要求更高。
　　在我的另一篇部落格詳細應用：Android效能優化之詳解IntentService

1.4 Handler、Thread和HandlerThread的差別

　　Handler會關聯一個單獨的執行緒、Looper和訊息佇列；他預設關聯主執行緒，如果要在其他執行緒執行，可以使用HandlerThread。
　　HandlerThread繼承於Thread，所以它本質就是個Thread。

它與普通Thread的差別就在於：建立了一個Thread，有自己的Looper和創立了訊息佇列，可以讓在自己的執行緒中分發和處理訊息。

2 HandlerThread原始碼分析

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

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

    /**
     * 此方法返回與此執行緒關聯的Looper。 
     * 如果這個執行緒沒有被啟動，或者由於任何原因isAlive()返回false，這個方法將返回null。
     * 如果這個執行緒已經啟動，這個方法將被阻塞，直到活套被初始化。 
     * @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;
    }

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

    /**
     * Returns the identifier of this thread. 
     */
    public int getThreadId() {
        return mTid;
    }
}

3 使用例子

3.1 例子

public class HandlerThreadActivity extends AppCompatActivity {

    private TextView mTvServiceInfo;

    private static final int MSG_UPDATE_INFO = 0x110;
    private boolean isUpdateInfo;

    private HandlerThread mCheckMsgThread;
    //使用HandlerThread執行緒的looper建立的mCheckMsgHandler
    private Handler mCheckMsgHandler;

    //主執行緒建立的mHandler來更新ui.
    private Handler mHandler = new Handler();

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

        //建立後臺執行緒
        initBackThread();

        mTvServiceInfo = (TextView) findViewById(R.id.id_textview);
    }

    @Override
    protected void onResume() {
        super.onResume();
        //開始查詢
        isUpdateInfo = true;
        mCheckMsgHandler.sendEmptyMessage(MSG_UPDATE_INFO);
    }

    @Override
    protected void onPause() {
        super.onPause();
        //停止查詢
        isUpdateInfo = false;
        mCheckMsgHandler.removeMessages(MSG_UPDATE_INFO);
    }

    private void initBackThread() {
        mCheckMsgThread = new HandlerThread("check-message-coming");
        mCheckMsgThread.start();
        mCheckMsgHandler = new Handler(mCheckMsgThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                checkForUpdate();
                if (isUpdateInfo) {
                    mCheckMsgHandler.sendEmptyMessageDelayed(MSG_UPDATE_INFO, 1000);
                }
            }
        };
    }

    /**
     * 模擬從伺服器解析資料
     */
    private void checkForUpdate() {
        try {
            //模擬耗時
            Thread.sleep(1000);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    String result = "實時更新中，當前大盤指數：<font color='red'>%d</font>";
                    result = String.format(result, (int) (Math.random() * 3000 + 1000));
                    mTvServiceInfo.setText(Html.fromHtml(result));
                }
            });
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //釋放資源
        mCheckMsgThread.quit();
    }
}

3.2 執行效果

這裡寫圖片描述

4 解決一個需求

4.1 問題提出

　　在子執行緒中開啟相機，並且在子執行緒中預覽回撥（編碼），如何實現？

4.2 子執行緒中的方法執行在子執行緒還是UI執行緒

public class ThreadTest {
    static class MyTask extends Thread {
        @Override
        public void run() {//只有run方法屬於子執行緒
            System.out.println(Thread.currentThread().getName() + " _run");
        }
        void onPreviewFrame(){//在UI執行緒執行
            System.out.println(Thread.currentThread().getName() + " _onPreviewFrame");
        }
    }
    public static void main(String[] args) {
        //子執行緒
        MyTask task = new MyTask();
        task.start();
        //在UI執行緒執行
        task.onPreviewFrame();
    }
}

4.3 方法對比

4.3.1 普通執行緒與Camera

　　非同步任務（AsyncTask）的Looper（因為子執行緒沒建立looper），使用的MainLooper。

public class AsyncTaskActivity1 extends Activity implements Callback {
    static final String TAG = "guan";
    Camera mCamera;
    SurfaceView surfaceView;
    SurfaceHolder surfaceHolder;
    byte[] buffers;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread2);
        surfaceView = (SurfaceView) findViewById(R.id.surface_view);
        surfaceHolder = surfaceView.getHolder();
        surfaceHolder.addCallback(this);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        new MyTask().execute();
    }

    class MyTask extends AsyncTask<Void, Void, Void> implements PreviewCallback{

        @Override
        protected Void doInBackground(Void... params) {
            //子執行緒中開啟
            Log.e(TAG, Thread.currentThread().getName() + "_open");
            mCamera = Camera.open(CameraInfo.CAMERA_FACING_BACK);
            try {
                mCamera.setPreviewDisplay(surfaceHolder);
            } catch (IOException e) {
                e.printStackTrace();
            }
            Camera.Parameters parameters = mCamera.getParameters();
            //設定相機引數
            parameters.setPreviewSize(480, 320); //預覽畫面寬高
            mCamera.setParameters(parameters);
            //獲取預覽影象資料
            buffers = new byte[480 * 320 * 4];
            mCamera.addCallbackBuffer(buffers);
            mCamera.setPreviewCallbackWithBuffer(this);
            mCamera.startPreview();

            Log.d(TAG, Thread.currentThread().getName()+ "_doInBackground");
            return null;
        }

        //畫面預覽的回撥
        @Override
        public void onPreviewFrame(byte[] data, Camera camera) {
            if(mCamera != null){
                mCamera.addCallbackBuffer(buffers);
                //編碼
                Log.d(TAG, Thread.currentThread().getName()+ "_onPreviewFrame");
            }
        }
    }
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    }
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
    }
}

　　列印結果：
這裡寫圖片描述
　　結果表明：畫面預覽的回撥方法onPreviewFrame()在UI執行緒中執行，未實現需求要求。

4.3.2 HandlerThread執行緒與Camera

public class HandlerThreadActivity4 extends Activity implements Callback {
    static final String TAG = "guan";
    Camera mCamera;
    SurfaceView surfaceView;
    SurfaceHolder surfaceHolder;
    byte[] buffers;

    HandlerThread mHandlerThread;
    Handler subHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread2);
        surfaceView = (SurfaceView) findViewById(R.id.surface_view);
        surfaceHolder = surfaceView.getHolder();
        surfaceHolder.addCallback(this);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        mHandlerThread = new HandlerThread("my_handlerthread");
        mHandlerThread.start();
        subHandler = new Handler(mHandlerThread.getLooper());
        subHandler.post(new MyTask());
    }

    class MyTask implements Runnable, PreviewCallback{
        @SuppressLint("NewApi") @Override
        public void run() {
            //開啟相機
            //子執行緒中開啟
            Log.d("guan", Thread.currentThread().getName() + "_open");
            mCamera = Camera.open(CameraInfo.CAMERA_FACING_BACK);
            try {
                mCamera.setPreviewDisplay(surfaceHolder);
            } catch (IOException e) {
                e.printStackTrace();
            }
            Camera.Parameters parameters = mCamera.getParameters();
            //設定相機引數
            parameters.setPreviewSize(480, 320); //預覽畫面寬高
            mCamera.setParameters(parameters);
            //獲取預覽影象資料
            buffers = new byte[480 * 320 * 4];
            mCamera.addCallbackBuffer(buffers);
            mCamera.setPreviewCallbackWithBuffer(this);
            mCamera.startPreview();

            Log.d(TAG, Thread.currentThread().getName()+ "_run");
        }

        @Override
        public void onPreviewFrame(byte[] data, Camera camera) {
            if(mCamera != null){
                mCamera.addCallbackBuffer(buffers);
                //編碼
                Log.d(TAG, Thread.currentThread().getName()+ "_onPreviewFrame");
            }
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
    }
}

　　列印結果：
這裡寫圖片描述
　　結果表明：畫面預覽的回撥方法onPreviewFrame()在子執行緒中執行，完美實現需求要求。

4.3.3 解析原因–Camera原始碼

　　new Camera -> looper -> EventHandler.handleMessage -> onPreviewFrame

public class Camera {
    private int cameraInitVersion(int cameraId, int halVersion) {
        mShutterCallback = null;
        mRawImageCallback = null;
        mJpegCallback = null;
        mPreviewCallback = null;
        mPostviewCallback = null;
        mUsingPreviewAllocation = false;
        mZoomListener = null;

        Looper looper;
        if ((looper = Looper.myLooper()) != null) {//Handler執行緒Looper
            mEventHandler = new EventHandler(this, looper);
        } else if ((looper = Looper.getMainLooper()) != null) {//UI執行緒Looper
            mEventHandler = new EventHandler(this, looper);
        } else {
            mEventHandler = null;
        }

        return native_setup(new WeakReference<Camera>(this), cameraId, halVersion,
                ActivityThread.currentOpPackageName());
    }

    private class EventHandler extends Handler {
        private final Camera mCamera;

        public EventHandler(Camera c, Looper looper) {
            super(looper);
            mCamera = c;
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case CAMERA_MSG_PREVIEW_FRAME:
                    PreviewCallback pCb = mPreviewCallback;
                    if (pCb != null) {
                        if (mOneShot) {
                            mPreviewCallback = null;
                        } else if (!mWithBuffer) {                                            setHasPreviewCallback(true, false);
                        }
                        //回撥onPreviewFrame()方法
                        //onPreviewFrame的執行，在Camera所持有的Looper執行緒中執行
                        pCb.onPreviewFrame((byte[]) msg.obj, mCamera);
                    }
                    return;
            }
        }
    }
}

5 參考連結

相關推薦

Android效能優化之實現擁有Looper的執行緒--HandlerThread

1 HandlerThread 1.1 定義 　　HandlerThread是能夠新建擁有Looper的Thread，這個Looper能夠用來新建其他的Handler。HandlerThread本質是一個執行緒，線上程內部，程式碼是序列處理的。（執行緒中

Android——效能優化之SparseArray

相信大家都用過HashMap用來存放鍵值對，最近在專案中使用HashMap的時候發現，有時候 IDE 會提示我這裡的HashMap可以用SparseArray或者SparseIntArray等等來代替。 SparseArray(稀疏陣列).它是Android內部特有的api,標準的jdk是沒有這

Android效能優化之較精確的獲取影象顯示到螢幕上的時間

轉載自：http://blog.desmondyao.com/android-show-time/ 這兩天我的包工頭歪龍木·靈魂架構師·王半仙·Yrom給我派了一個活：統計App冷啟動時間。這個任務看上去不難，但是要求統計出來的時間要準，要特別準。 意思就是，我必須要按Activity繪製到

Android效能優化之圖片壓縮優化

1 分類Android圖片壓縮結合多種壓縮方式，常用的有尺寸壓縮、質量壓縮、取樣率壓縮以及通過JNI呼叫libjpeg庫來進行壓縮。 參考此方法：Android-BitherCompress 備註：對於資源圖片直接使用：tiny壓縮 2 質量壓縮（1）原理：保持畫素的前提下改變圖片的位深及透明度，（即：通

Android效能優化之apk瘦身技巧

隨著專案迭代,新功能的增加。回導致apk越大。那麼在下載安裝過程中。使用者耗費的流量越多。 安裝等待的時間也會越長。這就意味著下載轉化率會越低。那麼如何apk瘦身呢？ 理解APK結構 在討論怎麼減小Apk體積之前，理解一個應用的APK結構是非常有幫助的。一個ap

Android效能優化之佈局優化

          佈局優化可以通過減少佈局層級來提高，儘量減少使用效能低的佈局，LineaLayout的效率最高，在可以使用LinearLayout或者RelativeLayout時，選擇LinearLayout。因為RelativeLayout測量較為複雜，需要測量水平和

Android 效能優化之String篇

Android 效能優化之 String篇 關於String相關知識都是老掉牙的東西了，但我們經常可能在不經意的String 字串拼接的情況下浪費記憶體，影響效能，也常常會成為觸發記憶體OOM的最後一步。 所以本文對String字串進行深度解析，有

Android效能優化之：XML佈局檔案優化

Android中XML佈局檔案的使用非常頻繁，在載入XML佈局的時候，如果對XML檔案其進行優化，將會提高載入的效率。 HierarchyViewer工具 再開始介紹之前先說一下HierarchyViewer工具的使用。 不合理的佈局會使我們的應用程式

Android效能優化之提高ListView效能的技巧

ListView優化一直是一個老生常談的問題，不管是面試還是平常的開發中，ListView永遠不會被忽略掉，那麼這篇文章我們來看看如何最大化的優化ListView的效能。 1.在adapter中的getView方法中儘量少使用邏輯 2.盡最大可能避免GC 3

Android 效能優化之記憶體洩漏檢測以及記憶體優化（中）

Android 記憶體洩漏檢測 　　通過上篇部落格我們瞭解了 Android JVM/ART 記憶體的相關知識和洩漏的原因，再來歸類一下記憶體洩漏的源頭，這裡我們簡單將其歸為一下三類：自身編碼引起由專案開發人員自身的編碼造成；第三方程式碼引起這裡的第三

Android 效能優化之記憶體檢測、卡頓優化、耗電優化、APK瘦身

導語 自2008年智慧時代開始，Android作業系統一路高歌，10年智慧機發展之路，如今 Android 9.0 代號P  都發布了，Android系統性能已經非常流暢了。但是，到了各大廠商手裡，改原始碼自定系統，使得Android原生系統變得魚龍混雜。另外，到了不同層次的

Android效能優化之被忽視的Memory Leaks

起因 寫部落格就像講故事，得有起因，經過，結果，人物，地點和時間。今天就容我給大家講一個故事。人物呢，肯定是我了。故事則發生在最近的這兩天,地點在coder君上班的公司。那天無意中我發現了一個奇怪的現象，隨著我點開我們App的頁面，Memory Monitor

Android 效能優化之記憶體洩漏的檢測與修復

在 Android 開發中, 記憶體優化是APP效能優化中很重要的一個部分. 而在記憶體優化中, 最重要的就是修復記憶體洩漏問題. 本文就來介紹一下記憶體洩漏的基本概念以及常用的檢測手段. 1. 什麼是記憶體洩漏 簡單來說, 當一個物件不再被使用時,

Android效能優化之Android安裝包大小優化

  隨著應用業務功能的日益複雜，使用的第三方庫和SDK也會日益增加，這樣導致的直接後果就是安裝包的體積日漸增加，除了使用外掛化的手段，減少安裝包的體積，我們還可以從以下幾個方面著手，進行安裝包大小的優化。   程式碼混淆   ProGuard是一個開源的Java程式碼混淆器

Android效能優化之 App啟動原理分析及速度和時間優化

應用的啟動速度緩慢這是很多開發者都遇到的一個問題，比如啟動緩慢導致的黑屏，白屏問題，大部分的答案都是做一個透明的主題，或者是做一個Splash介面，但是這並沒有從根本上解決這個問題。那麼如何從根本上解決這個問題或者做到一定程度的緩解？ 一、應用的啟動方式 1、冷啟動：

Android 效能優化之記憶體洩漏檢測以及記憶體優化（下）

Android 記憶體優化 　　上篇部落格描述瞭如何檢測和處理記憶體洩漏，這種問題從某種意義上講是由於程式碼的錯誤導致的，但是也有一些是程式碼沒有錯誤，但是我們可以通過很多方式去降低記憶體的佔用，使得應用的整體記憶體處於一個健康的水平，下面總結一下記憶

Android 效能優化之應用啟動

寫在前面 最近工作轉到Android 效能優化方向，剛轉過來，相關經驗缺乏，紀錄一個目前讓人惱火的問題。非常遺憾，本文到目前為止還未能提供解決問題的優化方案，也沒有明確定位到導致效能問題的瓶頸所在。就像解數學題一樣，花費了大把時間，然並卵。之所以寫它

Android效能優化之UI渲染優化

原文轉自：http://www.cnblogs.com/yezhennan/p/5442031.html UI效能測試 效能優化都需要有一個目標，UI的效能優化也是一樣。你可能會覺得“我的app載入很快”很重要，但我們還需要了解終端使用者的期望，是否可以去量化這些期望

Android效能優化之工具篇 — — Android Lint

Lint簡介 Android lint是在ADT16提供的新工具，它是一個程式碼掃描工具，能夠幫助我們識別資源、程式碼結構存在的問題。 Lint優化哪些問題 遺漏的翻譯（沒用上的翻譯）比如國際化未被翻譯的欄位值 佈局效能（以前是 layoutop

Android效能優化之路（五年之癢）

記得在上學的時候，就聽說在某個方面堅持學習一年，也就入門了。很慶幸，工作五年了，一直都在做Android效能優化。一般來說，工作三年左右會是工作的一個門檻，五年左右會是另外一個門檻，所以最近非常的低落、迷茫。昨晚外面下著漂泊大雨，輾轉反側的我，在想自己這從業五年