android 程序/執行緒管理（三）----Thread,Looper / HandlerThread / IntentService

阿新 • • 發佈：2019-01-19

Thread,Looper的組合是非常常見的組合方式。

Looper可以是和執行緒繫結的，或者是main looper的一個引用。

下面看看具體app層的使用。

首先定義thread：

package com.joyfulmath.androidstudy.thread;

import com.joyfulmath.androidstudy.TraceLog;

import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;

 
public class MyLoopThread extends Thread {
        
    private Looper myLooper = null;
    private MyHandler mHandler = null;
    public MyLoopThread()
    {
        super();
    }
    
    @Override
    public void run() {
        TraceLog.i("MyLoopThread looper prepare");
        Looper.prepare();
 
//        myLooper = Looper.getMainLooper(); /*using this can be set as main handler*/
        myLooper = Looper.myLooper();
        mHandler =  new MyHandler(myLooper);
        TraceLog.i("MyLoopThread looper loop");
        Looper.loop();
    }
    
    
    public void doAction(int index,String params)
    {
         
if(index>0 && index <=3)
        {
            Message msg = mHandler.obtainMessage(index);
            Bundle bundle = new Bundle();
            bundle.putString("key", params);
            msg.setData(bundle);
            mHandler.sendMessage(msg);
        }
        else
        {
            TraceLog.w(index+"");
        }
    }
    
    public static  class MyHandler extends Handler{
        
        public MyHandler()
        {
            super();
        }
        
        public MyHandler(Looper loop)
        {
            super(loop);
        }
        
        /*make sure that the looper is main or not
         *so you can update UI or send main handler to do it. 
         * */
        @Override
        public void handleMessage(Message msg) {
            Bundle bundle = msg.getData();
            String params = bundle.getString("key");
            TraceLog.i(params);
            switch(msg.what)
            {
            case ThreadConstant.INDEX_1:
                TraceLog.d("INDEX_1");
                break;
            case ThreadConstant.INDEX_2:
                TraceLog.d("INDEX_2");
                break;
            case ThreadConstant.INDEX_3:
                TraceLog.d("INDEX_3");
                break;    
            }
        }
    }
}

上面這個MyLoopThread類把，hangler，looper，thread融合在一起了，我們看看關鍵的地方：

    @Override
    public void run() {
        TraceLog.i("MyLoopThread looper prepare");
        Looper.prepare();
//        myLooper = Looper.getMainLooper(); /*using this can be set as main handler*/
        myLooper = Looper.myLooper();
        mHandler =  new MyHandler(myLooper);
        TraceLog.i("MyLoopThread looper loop");
        Looper.loop();
    }

如上，Thread只在說一件是，訊息迴圈。而且可以傳送訊息到主執行緒來處理。

如果MyLoopThread裡面定義兩個handler，會不會有衝突呢？

我們用程式碼試試看。

我們修改下run以及新增doaction2：

@Override
    public void run() {
        TraceLog.i("MyLoopThread looper prepare");
        Looper.prepare();
//        myLooper = Looper.getMainLooper(); /*using this can be set as main handler*/
        myLooper = Looper.myLooper();
        mHandler =  new MyHandler(myLooper);
        mHandler2 = new Handler(myLooper){

            @Override
            public void handleMessage(Message msg) {
                Bundle bundle = msg.getData();
                String params = bundle.getString("key");
                TraceLog.i("Handler2 "+params);
                switch(msg.what)
                {
                case ThreadConstant.INDEX_1:
                    TraceLog.d("Handler2 INDEX_1");
                    break;
                case ThreadConstant.INDEX_2:
                    TraceLog.d("Handler2 INDEX_2");
                    break;
                case ThreadConstant.INDEX_3:
                    TraceLog.d("Handler2 INDEX_3");
                    break;    
                }
            }
            
            
        };
        TraceLog.i("MyLoopThread looper loop");
        Looper.loop();
    }

    public void doAction2(int index,String params)
    {
        if(index>0 && index <=3)
        {
            Message msg = mHandler2.obtainMessage(index);
            Bundle bundle = new Bundle();
            bundle.putString("key", params);
            msg.setData(bundle);
            mHandler2.sendMessage(msg);
        }
        else
        {
            TraceLog.w(index+"");
        }
    }

08-03 17:04:40.679: I/MyLoopThread(25483): run: MyLoopThread looper prepare [at (MyLoopThread.java:22)]
08-03 17:04:40.679: I/MyLoopThread(25483): run: MyLoopThread looper loop [at (MyLoopThread.java:50)]
08-03 17:04:40.769: I/Timeline(25483): Timeline: Activity_idle id: [email protected] time:141675759
08-03 17:04:42.709: I/MyLoopThread$MyHandler(25483): handleMessage: time millseconds one [at (MyLoopThread.java:107)]
08-03 17:04:42.709: D/MyLoopThread$MyHandler(25483): handleMessage: INDEX_2 [at (MyLoopThread.java:114)]
08-03 17:04:47.299: I/MyLoopThread$1(25483): handleMessage: Handler2 time millseconds two [at (MyLoopThread.java:33)]
08-03 17:04:47.299: D/MyLoopThread$1(25483): handleMessage: Handler2 INDEX_2 [at (MyLoopThread.java:40)]
08-03 17:04:52.829: I/MyLoopThread$MyHandler(25483): handleMessage: time millseconds one [at (MyLoopThread.java:107)]
08-03 17:04:52.829: D/MyLoopThread$MyHandler(25483): handleMessage: INDEX_3 [at (MyLoopThread.java:117)]
08-03 17:04:53.479: I/MyLoopThread$MyHandler(25483): handleMessage: time millseconds one [at (MyLoopThread.java:107)]
08-03 17:04:53.479: D/MyLoopThread$MyHandler(25483): handleMessage: INDEX_3 [at (MyLoopThread.java:117)]
08-03 17:04:54.909: I/MyLoopThread$1(25483): handleMessage: Handler2 time millseconds two [at (MyLoopThread.java:33)]
08-03 17:04:54.909: D/MyLoopThread$1(25483): handleMessage: Handler2 INDEX_1 [at (MyLoopThread.java:37)]
08-03 17:04:56.309: I/MyLoopThread$1(25483): handleMessage: Handler2 time millseconds two [at (MyLoopThread.java:33)]
08-03 17:04:56.309: D/MyLoopThread$1(25483): handleMessage: Handler2 INDEX_3 [at (MyLoopThread.java:43)]

檢視訊息可以看到， handler很好的處理了訊息，沒有出現錯亂的問題。

我們知道，對於每個thread，looper，messagequeue都是唯一的，那為什麼沒有出錯呢？

我們看看之前在《android 程序/執行緒管理（一）----訊息機制的框架》http://www.cnblogs.com/deman/p/4688054.html

中的looper.loop()

裡面有一句：

msg.target.dispatchMessage(msg);

是的，這就是分發和處理訊息。而target就是我們的handler。

HandlerThread:

對於上面的例子，google提供了一個更方便的解決方案：HandlerThread。

下面是HandlerThread的原始碼：

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

可以看到，handlerThread自己把looper給啟動了。

下面是使用handlerthread的程式碼，比thread，looper更為簡單。

package com.joyfulmath.androidstudy.thread;

import com.joyfulmath.androidstudy.TraceLog;

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;

public class MyHandlerThread extends HandlerThread{

    MyHandler myHandler = null;
    
    public MyHandlerThread(String name) {
        super(name);
    }
    
        
    @Override
    protected void onLooperPrepared() {
        super.onLooperPrepared();
        myHandler = new MyHandler(getLooper());
    }

    public void doAction(int index,String params)
    {
        if(index>0 && index <=3)
        {
            Message msg = myHandler.obtainMessage(index);
            Bundle bundle = new Bundle();
            bundle.putString("key", params);
            msg.setData(bundle);
            myHandler.sendMessage(msg);
        }
        else
        {
            TraceLog.w(index+"");
        }
    }

    public static  class MyHandler extends Handler{
        
        public MyHandler()
        {
            super();
        }
        
        public MyHandler(Looper loop)
        {
            super(loop);
        }
        
        /*make sure that the looper is main or not
         *so you can update UI or send main handler to do it. 
         * */
        @Override
        public void handleMessage(Message msg) {
            Bundle bundle = msg.getData();
            String params = bundle.getString("key");
            TraceLog.i(params);
            switch(msg.what)
            {
            case ThreadConstant.INDEX_1:
                TraceLog.d("INDEX_1");
                break;
            case ThreadConstant.INDEX_2:
                TraceLog.d("INDEX_2");
                break;
            case ThreadConstant.INDEX_3:
                TraceLog.d("INDEX_3");
                break;    
            }
        }
    }
}

    private void initView() {
        ...
        
        btnStart3 = (Button) findViewById(R.id.thread_start_id3);
        btnStart3.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                myHandlerThread.doAction((int)(Math.random()*3)+1, "handlerthread time millseconds");
            }
        });
    }

以上是啟動handlerthread的程式碼。

IntentService：

我們可以看看原始碼：

intentservice 本質上就是 service + handlerthread的組成方式！

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public IntentService(String name) {
        super();
        mName = name;
    }

    /**
     * Sets intent redelivery preferences.  Usually called from the constructor
     * with your preferred semantics.
     *
     * <p>If enabled is true,
     * {@link #onStartCommand(Intent, int, int)} will return
     * {@link Service#START_REDELIVER_INTENT}, so if this process dies before
     * {@link #onHandleIntent(Intent)} returns, the process will be restarted
     * and the intent redelivered.  If multiple Intents have been sent, only
     * the most recent one is guaranteed to be redelivered.
     *
     * <p>If enabled is false (the default),
     * {@link #onStartCommand(Intent, int, int)} will return
     * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent
     * dies along with it.
     */
    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    /**
     * You should not override this method for your IntentService. Instead,
     * override {@link #onHandleIntent}, which the system calls when the IntentService
     * receives a start request.
     * @see android.app.Service#onStartCommand
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    /**
     * Unless you provide binding for your service, you don't need to implement this
     * method, because the default implementation returns null. 
     * @see android.app.Service#onBind
     */
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * This method is invoked on the worker thread with a request to process.
     * Only one Intent is processed at a time, but the processing happens on a
     * worker thread that runs independently from other application logic.
     * So, if this code takes a long time, it will hold up other requests to
     * the same IntentService, but it will not hold up anything else.
     * When all requests have been handled, the IntentService stops itself,
     * so you should not call {@link #stopSelf}.
     *
     * @param intent The value passed to {@link
     *               android.content.Context#startService(Intent)}.
     */
    protected abstract void onHandleIntent(Intent intent);
}

IntentService

我們首先看onCreate：

    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

開啟了一個handlerthread，並且初始化mServiceHandler，

mServiceHandler就是一個普通的handler，只是把訊息處理給了onHandleIntent

        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }

所以intentservice例項就需要實現onHandleIntent方法，來處理訊息。

一下是intentservice使用的一個demo：

package com.joyfulmath.androidstudy.thread;

import com.joyfulmath.androidstudy.TraceLog;

import android.app.IntentService;
import android.content.Intent;

public class MyIntentService extends IntentService {

    public MyIntentService() {
        super("MyIntentService");
    }
    
    
    
    @Override
    public void onCreate() {
        super.onCreate();
        TraceLog.i();
    }



    @Override
    protected void onHandleIntent(Intent intent) {
        TraceLog.i();
        doAction(intent);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        TraceLog.i();
    }
    
    private void doAction(Intent intent)
    {
        String params = intent.getStringExtra("key");
        TraceLog.i(params);
        int index = intent.getIntExtra("index", -1);
        TraceLog.i(index+"");
    }
}

MyIntentService

可以看下log：

匯出的log，沒有tid，所以上傳了圖片。可以看到onHandleIntent執行在工作執行緒裡面。

IntentService會在處理完了以後，直接destory掉。

android 程序/執行緒管理（三）----Thread,Looper / HandlerThread / IntentService

Thread,Looper的組合是非常常見的組合方式。 Looper可以是和執行緒繫結的，或者是main looper的一個引用。下面看看具體app層的使用。首先定義thread： package com.joyfulmath.androidstudy.thread; import co

android 程序/執行緒管理（一）----訊息機制的框架

一：android 程序和執行緒程序是程式執行的一個例項。android通過4大主件，弱化了程序的概念，尤其是在app層面，基本不需要關係程序間的通訊等問題。但是程式的本質沒有變，尤其是多工系統，以事件為驅動的軟體系統基本模式都是如下：程式的入口一般是main： 1.初始化：比如建立視窗，申

android 程序/執行緒管理（二）----關於執行緒的迷思

一：程序和執行緒的由來程序是計算機科技發展的過程的產物。最早計算機發明出來，是為了解決數學計算而發明的。每解決一個問題，就要打紙帶，也就是打點。後來人們發現可以批量的設定命令，由計算機讀取這些命令，並挨個執行。在使用的過程中，有一個問題，如果要做I/O操作，是非常耗時的，這個時候CPU是閒著的

執行緒管理（三）執行緒的中斷

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：歐振聰執行緒的中斷一個多個執行緒在執行的Java程式，只有當其全部的執行緒執行結束時（更具體的說，是所有非守護執行緒結束或者

【朝花夕拾】Android多執行緒之（三）runOnUiThread篇——程式猿們的貼心小棉襖

runOnUiThread()的使用以及原理實在是太簡單了，簡單到筆者開始都懶得單獨開一篇文章來寫它。當然這裡說的簡單，是針對對Handler比較熟悉的童鞋而言的。不過麻雀雖小，五臟俱全，runOnUiThread()好歹也算得上是一方諸侯，在子執行緒切換

程序與執行緒學習（三）之執行緒之使用場合

在對程序、執行緒的學習稍加了解後，不僅會自問在什麼情況下要使用多執行緒？畢竟，對知識的學習而不在於知識本身，而是怎麼使用所學的知識，有什麼侷限性。但從耗時來講，我對多執行緒做了一些測試：程式如下：只有一個主執行緒來估計買票時間； #include "stdafx.h"

Chrome原始碼分析之程序和執行緒模型（三）

關於Chrome的執行緒模型，在他的開發文件中有專門的介紹，原文地址在這裡：http://dev.chromium.org/developers/design-documents/threading chrome的程序，chrome沒有采用一般應用程式的單程序多執行緒的模

多執行緒基礎（三）-多執行緒併發安全問題

多執行緒基礎（三）-多執行緒併發安全問題當多個執行緒併發操作同一資源時，由於執行緒切換實際不可控會導致操作邏輯執行順序出現混亂，嚴重時會導致系統癱瘓。例如下面的程式碼 public class SyncDemo { public static void main(Strin

java多執行緒-初探（三）

java多執行緒-初探（二）本章主要闡述synchronized同步關鍵字，以及未做同步將出現的問題。未做同步引發的問題舉例本文舉例：1萬個人一起吃1萬碗飯，兩個人隨便吃。吃完為止。正常想要的結果是：吃到第0碗的時候，程式執行結束，打印出剩

執行緒學習（三）：執行緒的互斥

生產者與消費者模型在講同步和互斥之前，首先了解一下消費者模型什麼是消費者模型？消費者模型是一個描述消費者和生產者之間的關係的一個模型，生產者和消費者模型指的是在一個場所中，兩個角色，三種關係消費者和消費者之間——互斥消費者之間是競爭關係，比如有一個

Linux多執行緒學習（三）pthread_key_create

函式 pthread_key_create() 用來建立執行緒私有資料。該函式從 TSD 池中分配一項，將其地址值賦給 key 供以後訪問使用。第 2 個引數是一個銷燬函式，它是可選的，可以為 NULL，為 NULL 時，則系統呼叫預設的銷燬函式進行相關的資料登出。如果不為空

執行緒池（三）

執行緒池（三）主要介紹執行緒池如何根據不同的場景配置，及簡單的使用示例。如有不正確之處，請斧正，謝謝！一、配置場景執行緒池初始化引數：corePoolSize，maxMumPoolSize，keepAlivetime，TimeUnit，ThreadFactory，BlockingQu

執行緒管理（四）操作執行緒的中斷機制

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：歐振聰操作執行緒的中斷機制在之前的指南里，你學習瞭如何中斷執行執行緒和如何對Thread物件的中斷控制。之前例子中的機制可以

執行緒管理（九）使用本地執行緒變數

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：方騰飛使用本地執行緒變數併發應用的一個關鍵地方就是共享資料。這個對那些擴充套件Thread類或者實現Runnable介面的物

執行緒管理（八）線上程裡處理不受控制的異常

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：方騰飛線上程裡處理不受控制的異常 Java裡有2種異常: 檢查異常（Checked exceptions）: 這些異常必須強

執行緒管理（二）獲取和設定執行緒資訊

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：歐振聰獲取和設定執行緒資訊 Thread類的物件中儲存了一些屬性資訊能夠幫助我們來辨別每一個執行緒，知道它的狀態，調整控制其優

執行緒執行者（三）建立一個大小固定的執行緒執行者

宣告：本文是《 Java 7 Concurrency Cookbook 》的第四章，作者： Javier Fernández González 譯者：許巧輝校對：方騰飛，葉磊建立一個大小固定的執行緒執行者當你使用由Executors類的 newCachedThreadPo

基本執行緒同步（三）在同步的類裡安排獨立屬性

宣告：本文是《 Java 7 Concurrency Cookbook 》的第二章，作者： Javier Fernández González 譯者：許巧輝校對：方騰飛在同步的類裡安排獨立屬性當你使用synchronized關鍵字來保護程式碼塊時，你必須通過一個物件的引用作為引

執行緒管理（七）守護執行緒的建立和執行

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：方騰飛守護執行緒的建立和執行 Java有一種特別的執行緒叫做守護執行緒。這種執行緒的優先順序非常低，通常在程式裡沒有其他執行緒

執行緒管理（五）執行緒的睡眠和恢復

宣告：本文是《 Java 7 Concurrency Cookbook 》的第一章，作者： Javier Fernández González 譯者：鄭玉婷校對：歐振聰執行緒的睡眠與恢復有時, 你會感興趣在一段確定的時間內中斷執行執行緒。例如, 程式的一個執行緒每分鐘檢查反應器狀態。其

android 程序/執行緒管理（三）----Thread,Looper / HandlerThread / IntentService

相關推薦