我們都知道,安卓主線程(也就是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從子線程同步到主線程的原理。
我畫了一幅圖來更加形象的展示這個機制:
主線程中的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);
}
