Android溫故而知新 - Handler

我們都知道,安卓主線程(也就是ui線程)中不能做耗時操作,一旦主線程阻塞了超過5秒鐘就會被系統強制關閉,甚至在主線程中訪問網絡都會直接拋異常。但是我們的ui操作又必須在主線程中進行。所以我們會在子線程中進行耗時的操作,完成之后將結果同步到主線程進行ui的刷新。

而Handler機制就是谷歌用來方便我們進行線程同步的,我們可以很方便的通過它,在子線程中將ui刷新的操作同步回主線程中進行。

使用Handler將ui刷新操作同步到主線程中進行

我們先來看一個例子直觀感受下如何使用Handler將ui刷新操作從子線程同步到主線程中進行:

public class MainActivity extends AppCompatActivity {
    private static final int MSG_UPDATE_PROGRESS_BAR_ABOVE = 1;
    private static final int MSG_UPDATE_PROGRESS_BAR_BELOW = 2;
    private ProgressBar mProgressBarAbove;
    private ProgressBar mProgressBarBelow;

    private Handler mHandler;


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

        mProgressBarAbove = (ProgressBar) findViewById(R.id.progressAbove);

        mProgressBarBelow = (ProgressBar) findViewById(R.id.progressBelow);

        mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);

                switch (msg.what) {
                    case MSG_UPDATE_PROGRESS_BAR_ABOVE:
                        mProgressBarAbove.setProgress(msg.arg1);
                        break;
                    case MSG_UPDATE_PROGRESS_BAR_BELOW:
                        Bundle data = msg.getData();
                        mProgressBarBelow.setProgress(data.getInt("progress"));
                        break;
                }
            }
        };

        new Thread(new Runnable() {
            @Override
            public void run() {
                int progressAbove = 0;
                int progressBelow = 0;

                while (progressAbove < 100 || progressBelow < 100) {
                    if (progressAbove < 100) {
                        progressAbove++;

                        Message above = new Message();
                        above.what = MSG_UPDATE_PROGRESS_BAR_ABOVE;
                        above.arg1 = progressAbove;
                        mHandler.sendMessage(above);
                    }

                    if (progressBelow < 100) {
                        progressBelow += 2;

                        Message below = mHandler.obtainMessage();
                        below.what = MSG_UPDATE_PROGRESS_BAR_BELOW;
                        Bundle data = new Bundle();
                        data.putInt("progress", progressBelow);
                        below.setData(data);
                        mHandler.sendMessage(below);
                    }

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

上面的例子很簡單,界面有上下兩條進度條,我們在子線程中使用Thread.sleep(100)模擬耗時操作,每隔100毫秒更新一下進度,上面的進度條進度每次加1,下面的進度條每次加2。

截圖

1.創建handler并重寫handleMessage方法

首先我們會創建一個Handler并重寫它的handleMessage,這個方法就是在主線程中被調用的,我們通過傳給這個方法的Message去刷新ui。

Message的what成員變量用來標識消息的類型,我們這里用來區分更新哪一個進度條。同時我們可以從Message中取得從子線程中傳過來的進度,然后直接在handleMessage里面刷新進度條的進度。

2.在子線程中發送Message給Handler

Message是在子線程中被創建的。如代碼所示,我們可以直接將它new出來,也可以使用mHandler.obtainMessage()從mHandler的Message池中獲取一個實例。

一般推薦使用obtainMessage的方式,因為Message池中的Message是可以被重復利用的,避免了創建對象申請內存的開銷。

在前面說過Message的what成員變量是用來標志消息的類型的,我們這里直接將MSG_UPDATE_PROGRESS_BAR_ABOVE或者MSG_UPDATE_PROGRESS_BAR_ABOVE賦值進去,在handleMessage的時候就能用它來區分到底更新哪個進度條了。

消息的值也有多種賦值方式。

第一種很簡單,Message提供了arg1、arg2、obj、replyTo等public成員變量,可以直接將想保存的數據賦值給他們,在handleMessage方法中就能直接獲取到他們了。

第二種就是創建一個Bundle對象,在Bundle對象中存入數據,然后再通過setData方法傳給Message,在handleMessage方法中通過getData可以獲得Message中保存的Bundle對象,從而獲得保存的數據。

同步到主線程的各種姿勢

使用Handler將操作同步到主線程中進行有兩種方式,一種是上面例子中的發送Message的方式。另一種是直接將一個Runnable傳給Handler,Handler就會在主線程中執行它:

  • sendEmptyMessage(int what)
  • sendEmptyMessageDelayed(int what, long delayMillis)
  • sendEmptyMessageAtTime(int what, long uptimeMillis)
  • sendMessage(Message msg)
  • sendMessageDelayed(Message msg, long delayMillis)
  • sendMessageAtTime(Message msg, long uptimeMillis)
  • sendMessageAtFrontOfQueue(Message msg)
  • post(Runnable r)
  • postDelayed(Runnable r, long delayMillis)
  • postAtTime(Runnable r, long uptimeMillis)
  • postAtTime(Runnable r, Object token, long uptimeMillis)
  • postAtFrontOfQueue(Runnable r)

上面就是可以使用的一些方法,send前綴的方法用于發送一個帶數據的Message對象,post前綴的方法用于安排一個Runnable對象到主線程中執行。他們都有延遲發送,定時發送等姿勢可以使用。

當然你也可以在Message或者Runnable未同步到主線程的時候使用下面的remove方法將他們取消:

  • removeMessages(int what)
  • removeMessages(int what, Object object)
  • removeCallbacks(Runnable r)
  • removeCallbacks(Runnable r, Object token)
  • removeCallbacksAndMessages(Object token)

實際上將Runnable post到Handler中的時候也是用Message去包裝的:

    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

在主線程分發消息的時候如果判斷到Message有callback則會直接執行callback,否則就將消息傳到handleMessage中進行處理:

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

Handler機制的基本原理

Handler機制有四個重要的組件:

  • Handler
  • Message
  • MessageQueue
  • Looper

Handler和Message通過前面的例子應該已經很清楚了,但是MessageQueue和Looper又是什么鬼?

MessageQueue顧名思義,就是Message的隊列,我們調用Handler的各種方法發送Message其實就是將Message放到MessageQueue中。

而Looper就將Message從MessageQueue中拿出來。Looper有一個loop方法,它里面有個死循環,不斷從MessageQueue中拿Message出來并且將它傳給Handler去處理。

我們在子線程中將Message放入MessageQueue,然后在主線程中運行Looper的loop方法,不斷從MessageQueue中獲取Message。這就是Message從子線程同步到主線程的原理。

我畫了一幅圖來更加形象的展示這個機制:

Handler機制

主線程中的Looper

有人會問了,我們也沒有在主線程中中調用Looper的loop方法啊,而且再說了loop中不是一個死循環嗎,如果在主線程中運行它的話不會被堵死嗎?

其實安卓在啟動主線程的時候就會自動創建一個Looper和執行Looper.loop()的了,不需要自己去手動操作。

至于第二個問題,我們可以直接開口安卓的源碼,我們可以在androidxref這個網址中在線瀏覽多個版本的安卓源碼。

一般來講我們認為ActivityThread.main(String[] args)就是安卓程序運行的入口,也就是我們熟悉的main方法。它其實很短,我們在它的最后可以看到Looper.loop()這個方法的確是被調用了的。

    public static void main(String[] args) {
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        Security.addProvider(new AndroidKeyStoreProvider());

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        AsyncTask.init();

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

但是調用了loop方法之后,線程不就被堵住了嗎?那主線程又是怎樣接收到按鍵消息和調用各種生命周期方法的?我們可以看到代碼里還有個sMainThreadHandler,這個sMainThreadHandler是個H類,它的定義如下:

private class H extends Handler {
    public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {
                    ...
                } break;
                case RELAUNCH_ACTIVITY: {
                    ...
                } break;
                ...
            }
        }
    }
}

看Activity的各個生命周期,還有事件處理也是通過Handler機制實現的!

使用Handler將消息同步到其他線程

根據上面的原理,其實我們不僅可以使用Handler將消息同步到主線程中,也能用它來將消息從主線程同步到子線程中去執行。

只需要在子線程中運行Looper的loop方法,讓它不斷獲取Message,然后在主線程中發送Message就能在子線程中被處理了。

代碼如下

    private Handler mHandler;
    
    private Thread mThread = new Thread(new Runnable() {
        @Override
        public void run() {
            Looper.prepare();

            mHandler = new Handler() {
                public void handleMessage(Message msg) {
                    // process incoming messages here
                }
            };
            Looper.loop();
        }
    });

我們在需要在子線程中先調用Looper.prepare()。這個是個靜態方法它用來創建一個Looper并綁定到當前的線程中。

然后創建Handler,Handler會自動綁定當前線程中的Looper。

最后調用Looper.loop()就大功告成了。

之后我們就能在主線程中使用mHandler將消息發送到子線程中處理了。

HandlerThread

在上面一節中我們看到,在子線程中創建Handler還需要手動調用Looper.prepare()和Looper.loop()。為了簡化操作,谷歌官方提供了HandlerThread給我們使用。

HandlerThread是Thread的子類,當HandlerThread啟動的時候會自動調用Looper.prepare()和Looper.loop(),它的run方法源碼如下:

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

于是我們只需要在Handler構造的時候傳入HandlerThread的Looper就行了:

HandlerThread handlerThread = new HandlerThread("HandlerThread");
handlerThread.start();

mHandler = new Handler(handlerThread.getLooper()) {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
    }
};

IntentService

我們知道Service的各個聲明周期函數也是在主線程中執行的,它也不能直接執行耗時操作。需要將耗時操作放到子線程中進行。

為了方便在Service中進行耗時操作,谷歌提供了Service的子類IntentService。它有和Service相同的生命周期,同時也提供了在子線程處理耗時操作的機制。

IntentService是一個抽象類,使用的時候需要繼承并實現它的onHandleIntent方法,這個方法是在子線程中執行的,可以直接在這里進行耗時操作。

其實IntentService內部也是通過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);
        }
    }

    public IntentService(String name) {
        super();
        mName = name;
    }

    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

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

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

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

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

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容