編輯:關於Android編程
Android在框架層提供了異步任務類,AysncTask,用於執行後台任務,並將執行結果更新到UI線程。為什麼要用異步任務呢?這是因為如果某個任務太耗時間的話,會阻塞UI主線程,而我們知道UI線程如果阻塞5秒的話,就會發生ANR(Application No Response)錯誤 ,就算沒有發生,主界面上看起來也會卡卡的,這顯然用戶體驗就不太好了。
而AsyncTask類則在不影響UI線程的情況下,另起子線程去做那些耗時比較久的任務,比如我們在TodoList中去讀取圖片這種情況,然後將處理後的結果再更新到UI線程,從而達到更好的用戶體驗。
下面是AsyncTask類的定義:
public abstract class AsyncTask{ private static final String LOG_TAG = "AsyncTask"; ...
從上面的代碼可以看出,AsyncTask是一個抽象類,所以在使用AsyncTask的時候,我們要繼承它,實現一個子類,並實現其中一個方法,如下:
class LoadImageTask extends AsyncTask{ @Override protected ImageView doInBackground(String... params) { String photoImagePath = params[0]; Bitmap bitmap = BitmapReader.readBigBitmapFromFile(photoImagePath,REQ_WIDTH); ImageView imageView = Helper.createImageViewFromBitmap(DetailActivity.this, bitmap); return imageView; } protected void onPostExecute(ImageView result) { imageViews.add(result); refreshGallery(); } }
對照 AsyncTask的三個參數,Params, Progress和Result,是泛型參數。
1)Params :參數,比如例子中定義的String類型,指向一個Image的路徑,這是傳給AysncTask的doInBackground方法。
2)Progress:這是在執行過程中會用到的一個參數,一般在顯示進度的時候會用到,在例子中不會用到,所以可以在這裡指定為Void。
3)Result:這是執行的結果對象,會作為onPostExecute方法的參數,在UI線程中處理。
由上面的例子也可以看到,一般我們實現的這個子類,要實現其中的兩個方法
1)doInBackground:這個方法,其實是在另外一個線程中執行的。
2)onPostExecute:而這個方法卻已經回到UI線程中來執行,所以可以在這裡將上一個方法中執行所得的結果在這裡更新到UI線程中。
那麼這裡面的機制是怎麼樣的呢,我們就來深入地看一下,也學習一下吧。
首先我們來看一下在Activity中,我們是怎麼樣來使用我們這個AsyncTask的吧,代碼如下:
@Override protected void onActivityResult(int requestCode, int resultCode, Intent data){ if (requestCode == REQUEST_FOR_CAMERA) { if(resultCode == RESULT_OK){ isPhotoTaken = true; photoFileNames.add(tempPhotoFileName); } } else if (requestCode == REQUEST_FOR_GALLERY) { if(resultCode == RESULT_OK){ isPhotoTaken = true; ContentResolver resolver = getContentResolver(); Uri uri = data.getData(); tempPhotoFileName = Helper.getImagePath(resolver, uri); photoFileNames.add(tempPhotoFileName); } } new LoadImageTask().execute(tempPhotoFileName);//調用其execute方法 }
進入AsyncTask類中,找到execute方法,如下:
public final AsyncTask可以看到,這裡調用的是executeOnExecutor方法,我們繼續找:execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); }
public final AsyncTask在這個方法中,我們可以發現,AsynctTask定義了一個mStatus的成員變量,來表示異步任務的運行狀態,分別是pending,running和finished,但只有處於pending狀態的AsnycTask才能被執行。當狀態是Pending的時候,就會繼續執行,將狀態變成running,這樣能夠保證AsyncTask只會被執行一次。executeOnExecutor(Executor exec, Params... params) { if (mStatus != Status.PENDING) { switch (mStatus) { case RUNNING: throw new IllegalStateException("Cannot execute task:" + " the task is already running."); case FINISHED: throw new IllegalStateException("Cannot execute task:" + " the task has already been executed " + "(a task can be executed only once)"); } } mStatus = Status.RUNNING; onPreExecute(); mWorker.mParams = params; exec.execute(mFuture); return this; }
接著會調用onPreExecute方法做一些處理工作,這個方法其實我們也可以在子類中自己實現,如果有什麼需要處理的話,一般不用。
然後我們發現,我們傳進來的參數params會被傳給mWorker,然後會有一個executor來執行execute的方法,並且執行的參數是一個mFuture對象。那麼這兩個東西是什麼呢?
接著看如下代碼:
public AsyncTask() { mWorker = new WorkerRunnable() { public Result call() throws Exception { mTaskInvoked.set(true); Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked return postResult(doInBackground(mParams)); } }; mFuture = new FutureTask (mWorker) { @Override protected void done() { try { postResultIfNotInvoked(get()); } catch (InterruptedException e) { android.util.Log.w(LOG_TAG, e); } catch (ExecutionException e) { throw new RuntimeException("An error occured while executing doInBackground()", e.getCause()); } catch (CancellationException e) { postResultIfNotInvoked(null); } } }; }
mWorker是一個WorkerRunnable對象,而實際上WorkerRunnable是AsyncTask的一個抽象內部類,實現了Callable接口,如下:
private static abstract class WorkerRunnableimplements Callable { Params[] mParams; }
public FutureTask(Callablecallable) { if (callable == null) throw new NullPointerException(); sync = new Sync(callable); }
而FutureTask是Java多線程模型的一部分,其間接地實現了Runnable(線程屬性)接口和Future(異步任務)接口,而在上面的executeOnExecutor方法中,正是將mWorker(實現了Callable接口)對象傳給它了,並被其封裝到成員變量sync中,這樣它們就共同表示了一個異步任務,到這裡,一個異步任務也就創建完成了。
從上面executeOnExecutor的方法,也可以看到,真正執行execute是一個Executor,而在AsyncTask中,其實是SerialExecutor,我們看看其構造函數:
private static class SerialExecutor implements Executor { final ArrayDequemTasks = new ArrayDeque (); Runnable mActive; public synchronized void execute(final Runnable r) { mTasks.offer(new Runnable() { public void run() { try { r.run();//在新線程中調用了我們上面傳進來的FutureTask的run方法 } finally { scheduleNext(); } } }); if (mActive == null) { scheduleNext(); } } protected synchronized void scheduleNext() { if ((mActive = mTasks.poll()) != null) { THREAD_POOL_EXECUTOR.execute(mActive); } } }
從上面,我們可以看到execute方法的參數就是一個Runnable,其實也就是FutrueTask了,在這裡,它會被封裝到一個新的線程中作為一個任務添加到mTasks隊列中,至於下面如何在THREAD_POOL_EXECUTOR中去執行mTasks我們就不再深入下去了,我們就來看看FutureTask的run方法,如下:
public void run() { sync.innerRun(); }
void innerRun() { if (!compareAndSetState(READY, RUNNING)) return; runner = Thread.currentThread(); if (getState() == RUNNING) { // recheck after setting thread V result; try { result = callable.call(); } catch (Throwable ex) { setException(ex); return; } set(result); } else { releaseShared(0); // cancel } }我們發現,它調用了callable的call方法,啊,我們終於來到了mWorker的call方法,回過頭看,不就是在那裡調用了doInBackground方法的嗎?所以,我們可以確定,doInBackground的確是在一個新的線程中執行的,並且是一個後台線程。
但同時我們發現,其執行完之後,是作為一個參數傳遞給postResult的,繼續看下去:
private Result postResult(Result result) { @SuppressWarnings("unchecked") Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult可以看到,在這裡是利用了sHandler來發送異步消息的,而sHandler是在AsynctTask中定義的,如下:(this, result)); message.sendToTarget(); return result; }
private static final InternalHandler sHandler = new InternalHandler();InternalHandler定義如下
private static class InternalHandler extends Handler { @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"}) @Override public void handleMessage(Message msg) { AsyncTaskResult result = (AsyncTaskResult) msg.obj; switch (msg.what) { case MESSAGE_POST_RESULT: // There is only one result result.mTask.finish(result.mData[0]); break; case MESSAGE_POST_PROGRESS: result.mTask.onProgressUpdate(result.mData); break; } } }
@SuppressWarnings({"RawUseOfParameterizedType"}) private static class AsyncTaskResult { final AsyncTask mTask; final Data[] mData; AsyncTaskResult(AsyncTask task, Data... data) { mTask = task; mData = data; } } }我們發現,在上面傳進來的AsyncTaskResult的參數task的正好就是this,而它又賦值給了mTask的,所以說明,這個mTask就是我們在Activity中定義的LoadImageTask了,而它是在主線程中定義的,那麼很顯然,它的finish方法也是在主線程,也就是UI線程中執行的了,再來看看這個finish方法:
private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED; }在這裡,我們終於看到了onPostExecute方法的調用了,這說明了,onPostExecute就是在UI線程中干活的了。最後mStatus也被設計成FIINISHED了,這個異步任務也就結束了。
嗯,關於AsyncTask的基本原理到這裡也就結束了。
Android中的消息處理機制大量依賴於Handler。每個Handler都有對應的Looper,用於不斷地從對應的MessageQueue中取出消息處理。一直以來,覺得
1、申請注冊你的appid2、下載sdkQQ: http://wiki.open.qq.com/wiki/mobile/SDK%E4%B8%8B%E8%BD%BD微信:h
最簡單的使用xml布局文件 Activity.javaList list = new ArrayList<>();list.add("
使用Android Sutdio創建一個新的工程後,接下來記錄創建NDK工程的基本步驟。本文將達到:1. 創建NDK工程2. 在JNI中輸出Log語句3. 指定編譯的so