溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
AsyncTask
什么是AsyncTask
AsyncTask是一個輕量級的異步任務類，它可以在線程池中執行后臺任務，然后把執行的進度和結果傳遞給主線程并在主線程中更新UI。
AsyncTask這個類的聲明如下
public abstract class AsyncTask<Params, Progress, Result>
它提供了Params, Progress和 Result三個泛型參數，在下面會仔細分析這三個泛型參數的具體含義。
AsyncTask提供了四個核心方法
onPreExecute()
此方法在主線程中執行，在異步任務執行之前，此方法會被調用，一般用于一些準備工作，例如下載進度條的初始化。
doInBackground(Params… params)
此方法在子線程中執行，用于執行異步任務，注意這里的params就是AsyncTask的第一個參數類型。在此方法中可以通過調用publicProgress方法來更新任務進度，publicProgress會調用onProgressUpdate方法。
onProgressUpdate(Progress… values)
此方法在主線程中執行，values的類型就是AsyncTask傳入的第二個參數類型，當后臺任務的執行進度發生變化時此方法執行。
onPostExecute(Result result)
此方法在主線程中執行，在doInBackground方法執行完成以后此方法會被調用，其中result的類型就是AsyncTask傳入的第三個參數類型，它的值就是doInBackground方法的返回值。
接著還是看一下AsyncTask最常見的用法，該事例就是下載一張圖片到手機內存的cache目錄下，下載開始時會彈出進度框，在下載過程中顯示下載的進度，下載完成后關閉進度框，如成功則出現下載成功的Toast，失敗則彈出失敗的Toast。
class MyAsyncTask extends AsyncTask<Void,Integer,Boolean> {
@Override
protected void onPreExecute() {
progressDialog = new ProgressDialog(MainActivity.this);
progressDialog.setTitle("下載進度");
progressDialog.setMax(100);
progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
progressDialog.setCancelable(true);
progressDialog.show();
}
@Override
protected Boolean doInBackground(Void... params) {
HttpURLConnection conn = null;
try {
conn = (HttpURLConnection) params[0].openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);
conn.setReadTimeout(5000);
final int contentLength;
if (conn.getResponseCode() == 200) {
contentLength = conn.getContentLength();
File file = new File(getCacheDir(),"hh.jpg");
InputStream is= null;
FileOutputStream fos= new FileOutputStream(file);
is = conn.getInputStream();
int len = 0;
long totalSize = 0;
byte[] bytes = new byte[102];
while ((len = is.read(bytes))!=-1) {
fos.write(bytes,0,len);
totalSize += len*100;
int progress = (int) (totalSize/contentLength);
publishProgress(progress);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
@Override
protected void onProgressUpdate(Integer... values) {
progressDialog.setProgress(values[0]);
}
@Override
protected void onPostExecute(Boolean aBoolean) {
progressDialog.dismiss();
if (result) {
Toast.makeText(context, "下載成功", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(context, "下載失敗", Toast.LENGTH_SHORT).show();
}
}
}
這個類主要用于模擬文件的下載過程，它輸入參數為圖片url地址，后臺的進程參數為Integer類型，后臺任務的返回結果為bollean類型。當要執行上述下載任務時，可以通過如下方式來完成：
//在主線程中調用，執行后就會執行doInBackground等方法
URL url = new URL("http://192.168.43.21:8080/ditu.jpg");
new MyAsyncTask().execute(url);
源碼分析
首先我們從AsyncTask的構造方法著手。
/**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask<Result>(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 occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
1.如注釋所說，這個構造方法必須在UI線程中調用。
2.構造函數主要是創建了兩個實例。一個是WorkerRunnable，它是一個Callback對象。另一個是FutureTask，它的參數就是前面創建的WorkerRunnable對象。
接下來我們再看AsyncTask的execute()方法，這個方法是整個異步任務的入口。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
public final AsyncTask<Params, Progress, Result> 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()調用
onPreExecute();
//這里的參數由AsyncTask構造函數傳進來的第一個參數，傳入到doInBackground(mParams)中
mWorker.mParams = params;
//*******************
exec.execute(mFuture);
return this;
}
我們看到了onPreExecute()被調用了，證明它確實是在執行后臺任務之前調用了，且是在主線程調用。此時我們執行了實例代碼中的進度條顯示框的顯示操作，此時的界面如下
，在此方法中還進行了一個操作exec.execute(mFuture)，首先我們得知道exec到底是什么？在下面源碼中我們就能得到答案。
public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
根據如上代碼以及executeOnExecutor傳進來的參數，我們看到這里的exec其實就是SerialExecutor，那我們就來看看SerialExecutor的execute方法
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
我們看到在子線程里執行了r.run(),根據execute()方法傳入的參數可知這里的r就是最開始在構造方法中創建的FutureTask，當然接下來就該看看FutureTask的run()方法了
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//****************************
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
這里有一個result = c.call()方法，而這里的c就是Callable c = callable;里傳進來的callable，而callable就是我們最開始在AsyncTask構造方法里傳進來的WorkerRunnable，所以接著就該看看WorkerRunnable的call()方法，這個call()方法主要是調用了doInBackground(mParams)和postResult(result)方法
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
//*********************************
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
1.在這里我們看到doInBackground(mParams)方法的調用，并且此時仍然是在子線程中，所以在這里可以執行耗時操作。在上面的案例中doInBackground方法里的代碼將會執行，當執行到publishProgress()方法時，會不斷將進度信息傳遞給onProgressUpdate()方法（后面的分析中會解釋為什么publishProgress()的執行能導致onProgressUpdate()方法的調用），讓此方法執行更新UI.執行到這里時，案例中的下載界面如下，此時進度正好走到50%：
2.方法的最后執行了postResult(result)方法，這里面的result參數就是我們doInBackground(mParams)的返回值，這個方法的主要作用就是創建一個InternalHandler實例并發送what=MESSAGE_POST_RESULT的消息，我們接著看這個方法的源碼
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
//message方法的sendToTarget()，最終還是handler發送信息個消息隊列
public void sendToTarget() {
target.sendMessage(this);
}
熟悉handler的朋友知道，target.sendMessage(this)方法就是將消息發送給了消息隊列，而這個攜帶的消息就是message本身，message當中攜帶有MESSAGE_POST_RESULT和new AsyncTaskResult(this, result))對象，而這個對象由getHandler發送，最后也會由它來handleMessage()（對這個消息進行處理），所以我們必須找到這個handler
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
//在這里創建了名為sHandler的InternalHandler實例
sHandler = new InternalHandler();
}
return sHandler;
}
}
根據上面getHandler()方法可知這個handler對象就是InternalHandler，那接下來的任務就是分析InternalHandler的handlerMessage()方法，這個方法的作用就是根據postResult(Result result)方法中的sHandler發送的不同消息進行判斷來執行不同的邏輯。
@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;
}
}
//result.mTask.finish(result.mData[0])方法如下
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
//result.mTask.onProgressUpdate(result.mData)
@MainThread
protected void onProgressUpdate(Progress... values) {
}
由上面源碼可知，它根據msg攜帶的不同what信息進行不同的消息處理，當what = MESSAGE_POST_RESULT時，最終會執行onCancelled(result)或者onPostExecute(result)，這兩個方法執行時全部都是在主線程，而MESSAGE_POST_RESULT就是剛剛獲取信息時傳入的。執行在這里時我們下載事例的代碼就走到了onPostExecute(result)，我們進行了進度框的隱藏操作，執行的界面如下：
但是MESSAGE_POST_PROGRESS參數又是哪里傳來的，沒錯，就是publishProgress(Progress… values)
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
這里傳入MESSAGE_POST_PROGRESS，并且此方法在WorkerThread中調用。這樣onProgressUpdate(Progress… values)方法就能順利執行。整個流程結束
總結
1.AsyncTask的對象只能在主線程中創建
2.execute()方法只能在UI線程執行
3.不要在程序中直接調用onPreExecute,onPostExecute,doInBackground,onProgressUpdate方法
4.一個AsyncTask對象只能執行一次execute方法，否者會報運行時錯誤，在執行execute方法時，會調用到如下代碼證明這個結論
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)");
}
}
5.在Android1.6之前，AsyncTask是串行執行任務，在1.6以后，改為在線程池里并行處理任務，在3.0以后，又改為在線程池里串行執行任務。
在AsyncTask中有兩個線程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一個handler(InternalHandler).
其中SerialExecutor用于任務的排隊。在上面代碼中，我們已經看到，在AsyncTask.execute的執行過程中我們會調用它的execute方法
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
我們看到首先會將FutureTask對象插入到隊列mTask中，如果這個時候沒有正在執行的AsyncTask活動，就會調用scheduleNext();執行下一個任務，當一個任務執行完成后又會執行下一個，從這可以看出AsyncTask默認是串行執行的
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持億速云。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
