Android AsyncTask使用以及源碼解析

更新時間：2017年01月16日 11:34:05 作者：無嘴小呆子

這篇文章主要為大家詳細(xì)解析了Android AsyncTask使用以及源碼，具有一定的參考價值，感興趣的小伙伴們可以參考一下

綜述

　　在Android中，我們需要進行一些耗時的操作，會將這個操作放在子線程中進行。在子線程操作完成以后我們可以通過Handler進行發(fā)送消息，通知UI進行一些更新操作（具體使用及其原理可以查看Android的消息機制——Handler的工作過程這篇文章）。當(dāng)然為了簡化我們的操作，在Android1.5以后為我們提供了AsyncTask類，它能夠?qū)⒆泳€程處理完成后的結(jié)果返回到UI線程中，之后我們便可以根據(jù)這些結(jié)果進行一列的UI操作了。

AsyncTask的使用方法

　　實際上AsyncTask內(nèi)部也就是對Handler和線程池進行了一次封裝。它是一個輕量級的異步任務(wù)類，它的后臺任務(wù)在線程池中進行。之后我們可以將任務(wù)執(zhí)行的結(jié)果傳遞給主線程，這時候我們就可以在主線程中操作UI了。
　　AsyncTask他是一個抽象的泛型類，所以我們創(chuàng)建一個子類，來實現(xiàn)AsyncTask中的抽象方法。AsyncTask中提供了三個泛型參數(shù)，下面我們就來看一下這三個泛型參數(shù).
　　1. Params:在執(zhí)行AsyncTask時所傳遞的參數(shù)，該參數(shù)在后臺線程中使用。
　　2. Progress:后臺任務(wù)執(zhí)行進度的類型
　　3. Result:后臺任務(wù)執(zhí)行完成后返回的結(jié)果類型。
　　對于以上三個泛型參數(shù)我們不需要使用的時候，可以使用Void來代替。與Activity生命周期類似，在AsyncTask中也為我們提供了一些方法，我們通過重寫這幾個方法來完成整個異步任務(wù)。我們主要使用的方法有一下四個:
　　1. onPreExecute():該方法在異步任務(wù)工作之前執(zhí)行，主要用于一些參數(shù)或者UI的初始化操作。
　　2. doInBackground(Params… params):該方法在線程池中執(zhí)行，params參數(shù)表示異步任務(wù)時輸入的參數(shù)。在這個方法中我們通過publishProgress來通知任務(wù)進度。
　　3. onProgressUpdate(Progress… values):當(dāng)后臺任務(wù)的進度發(fā)生改變的時候會調(diào)用該方法，我們可以再這個方法中進行UI的進度展示。values參數(shù)表示任務(wù)進度。
　　4. postResult(Result result):在異步任務(wù)完成之后執(zhí)行，result參數(shù)為異步任務(wù)執(zhí)行完以后所返回的結(jié)果。
　　在上面四個方法中只有doInBackground在子線程中運行，其余都三個方法都是在主線程中運行的。其中的…表示參數(shù)的數(shù)量不定，是一種數(shù)組類型的參數(shù)。
　　下面我們就來寫一個例子來看一下AsyncTask的用法，在這里我們就一個下載的功能，從網(wǎng)絡(luò)上下載兩個文件。我們先來看一下效果演示。

效果演示

代碼分析

　　由于我們做的下載任務(wù)，首先我們就得添加訪問網(wǎng)絡(luò)權(quán)限以及一些sd卡相關(guān)的權(quán)限。

<!-- 在SD卡中創(chuàng)建與刪除文件權(quán)限 -->
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
<!-- 向SD卡寫入數(shù)據(jù)權(quán)限 -->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<!-- 授權(quán)訪問網(wǎng)絡(luò) -->
<uses-permission android:name="android.permission.INTERNET"/>

下面我們來看一下Activity代碼。

package com.example.ljd.asynctask;

import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

 private DownloadAsyncTask mDownloadAsyncTask;

 private Button mButton;
 private String[] path = {
   "http://msoftdl.#/mobilesafe/shouji360/360safesis/360MobileSafe_6.2.3.1060.apk",
   "http://dlsw.baidu.com/sw-search-sp/soft/7b/33461/freeime.1406862029.exe",
 };

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  mButton = (Button)findViewById(R.id.button);
  mButton.setOnClickListener(this);
 }

 @Override
 protected void onDestroy() {
  if (mDownloadAsyncTask != null){
   mDownloadAsyncTask.cancel(true);
  }
  super.onDestroy();
 }

 @Override
 public void onClick(View v) {

  mDownloadAsyncTask = new DownloadAsyncTask();
  mDownloadAsyncTask.execute(path);
 }

 class DownloadAsyncTask extends AsyncTask<String,Integer,Boolean>{

  private ProgressDialog mPBar;
  private int fileSize;  //下載的文件大小
  @Override
  protected void onPreExecute() {
   super.onPreExecute();
   mPBar = new ProgressDialog(MainActivity.this);
   mPBar.setProgressNumberFormat("%1d KB/%2d KB");
   mPBar.setTitle("下載");
   mPBar.setMessage("正在下載，請稍后...");
   mPBar.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
   mPBar.setCancelable(false);
   mPBar.show();
  }

  @Override
  protected Boolean doInBackground(String... params) {
   //下載圖片
   for (int i=0;i<params.length;i++){
    try{
     if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
      URL url = new URL(params[i]);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      //設(shè)置超時時間
      conn.setConnectTimeout(5000);
      //獲取下載文件的大小
      fileSize = conn.getContentLength();
      InputStream is = conn.getInputStream();
      //獲取文件名稱
      String fileName = path[i].substring(path[i].lastIndexOf("/") + 1);
      File file = new File(Environment.getExternalStorageDirectory(), fileName);
      FileOutputStream fos = new FileOutputStream(file);
      BufferedInputStream bis = new BufferedInputStream(is);
      byte[] buffer = new byte[1024];
      int len ;
      int total = 0;
      while((len =bis.read(buffer))!=-1){
       fos.write(buffer, 0, len);
       total += len;
       publishProgress(total);
       fos.flush();
      }
      fos.close();
      bis.close();
      is.close();
     }
     else{
      return false;
     }
    }catch (IOException e){
     e.printStackTrace();
     return false;
    }
   }

   return true;
  }

  @Override
  protected void onPostExecute(Boolean aBoolean) {
   super.onPostExecute(aBoolean);
   mPBar.dismiss();
   if (aBoolean){
    Toast.makeText(MainActivity.this,"下載完成",Toast.LENGTH_SHORT).show();
   } else {
    Toast.makeText(MainActivity.this,"下載失敗",Toast.LENGTH_SHORT).show();
   }
  }

  @Override
  protected void onProgressUpdate(Integer... values) {
   super.onProgressUpdate(values);
   mPBar.setMax(fileSize / 1024);
   mPBar.setProgress(values[0]/1024);
  }
 }

}

在以上代碼中有幾點我們需要注意一下。
　　1. AsyncTask中的execute方法必須在主線程中執(zhí)行。
　　2. 每個AsyncTask對象只能執(zhí)行一次execute方法。
　　3. 當(dāng)我們的Activity銷毀的時候需要進行取消操作，其中boolean型的參數(shù)mayInterruptIfRunning表示是否中斷后臺任務(wù)。
　　最后的布局代碼就很簡單了，只有一個Button而已。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:padding="@dimen/activity_vertical_margin"
  android:orientation="vertical"
  tools:context="com.example.ljd.asynctask.MainActivity">

  <Button
    android:id="@+id/button"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="download"/>
</LinearLayout>

　　這里還有一點需要說明一下，由于在不同的Android版本中對AsyncTask進行了多次修改，所以當(dāng)我們通過多個AsyncTask對象執(zhí)行多次execute方法的時候，它們執(zhí)行順序是串行還是并行根據(jù)系統(tǒng)不同的版本而出現(xiàn)差異，這里就不再具體分析。

AsyncTask源碼分析

　　在這里我們采用Android6.0中的AsyncTask源碼進行分析，對于不同系統(tǒng)的AsyncTask代碼會有一定的差異。當(dāng)創(chuàng)建一個AsyncTask對象以后我們便可以通過execute方法來執(zhí)行整個任務(wù)。那就在這里首先看一下execute方法中的代碼。

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
  return executeOnExecutor(sDefaultExecutor, params);
}

　　可以看到這個execute方法中的代碼是如此的簡單，只是執(zhí)行了executeOnExecutor方法并返回AsyncTask對象。下面我們就來看一下executeOnExecutor這個方法。

@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();

  mWorker.mParams = params;
  exec.execute(mFuture);

  return this;
}

　　在這個方法內(nèi)我們首先對AsyncTask所執(zhí)行的狀態(tài)進行判斷。如果AsyncTask正在執(zhí)行任務(wù)或者任務(wù)已經(jīng)知己完成就會給我們拋出異常，也就解釋上面所說的每個AsyncTask對象只能執(zhí)行一次execute方法。緊接著將當(dāng)前任務(wù)狀態(tài)修改為正在運行以后便開始執(zhí)行onPreExecute方法。這也說明了在上面我們重寫的四個方法中onPreExecute方法最先指向的。下面我們在看一下mWorker和mFuture這兩個全局變量。
　　mFuture是FutureTask對象，而mWorker是WorkerRunnable對象，WorkerRunnable是AsyncTask中的一個實現(xiàn)Callable接口的抽象內(nèi)部類，在WorkerRunnable中只定義了一個Params[]。

private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;

......

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
  Params[] mParams;
}

　　mFuture和mWorker是在AsyncTask的構(gòu)造方法中初始化的。我們看一下AsyncTask的構(gòu)造方法。

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);
      }
    }
  };
}

　　在這里首先創(chuàng)建一個WorkerRunnable對象mWorker，并且實現(xiàn)了Callable接口的call方法，對于這個call方面里面的內(nèi)容在后面會進行詳細(xì)說明。然后我們再通過mWorker，創(chuàng)建一個FutureTask對象mFuture，并且重寫里面的done方法，當(dāng)我們調(diào)用AsyncTask里面的cancel方法時，在FutureTask中會調(diào)用這個done方法。在這里介紹完mWorker和mFuture后我們再回過頭來看executeOnExecutor方法。在這里通過我們傳入的params參數(shù)初始化了mWorker中的mParams。而下面的exec則是在execute里面?zhèn)魅氲膕DefaultExecutor，并且執(zhí)行sDefaultExecutor的execute方法。下面我們再來看一下這個sDefaultExecutor對象。

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;

private static final ThreadFactory sThreadFactory = new ThreadFactory() {
  private final AtomicInteger mCount = new AtomicInteger(1);

  public Thread newThread(Runnable r) {
    return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
  }
};

private static final BlockingQueue<Runnable> sPoolWorkQueue =
    new LinkedBlockingQueue<Runnable>(128);

public static final Executor THREAD_POOL_EXECUTOR
    = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
        TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

......

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

......

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);
    }
  }
}

　　在這里首先整體介紹一下這段代碼。這段代碼的主要功能就是創(chuàng)建了兩個線程池SerialExecutor和THREAD_POOL_EXECUTOR。SerialExecutor線程池用于對任務(wù)的排隊，而THREAD_POOL_EXECUTOR則是用來執(zhí)行任務(wù)。而sDefaultExecutor就是SerialExecutor線程池。
　　我們進入SerialExecutor代碼中看一下里面的內(nèi)容。SerialExecutor中的execute方法內(nèi)的參數(shù)Runnable就是我們傳入的mFuture。在execute方法中創(chuàng)建了一個Runnable對象，并將該隊列插入對象尾部。這個時候如果是第一次執(zhí)行任務(wù)。mActive必然為null，這時候便調(diào)用scheduleNext方法從隊列中取出Runnable對象，并且通過THREAD_POOL_EXECUTOR線程池執(zhí)行任務(wù)。我們可以看到在隊列中的Runnable的run方法中首先執(zhí)行mFuture中的run方法，執(zhí)行完之后又會調(diào)用scheduleNext方法，從隊列中取出Runnable執(zhí)行，直到所有的Runnable執(zhí)行完為止。下面就來看一下在線城池中是如何執(zhí)行這個Runnable的。從上面代碼可以看出，在線城池中執(zhí)行Runnable其實最核心的部分還是執(zhí)行mFuture的run方法。那就來看一下這個mFuture中的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);
  }
}

　　在這個方法中的callable對象就是我們AsyncTask中的mWorker對象。在這里面也正是執(zhí)行mWorker中的call方法來完成一些耗時任務(wù)，于是我們就能想到我重寫的doInBackground應(yīng)該就在這個call方法中執(zhí)行了。現(xiàn)在再回到AsyncTask的構(gòu)造方法中看一下這個mWorker中的call方法。

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);
}

　　這里我們很清楚的看到它執(zhí)行我們重寫的doInBackground方法，并且將返回的結(jié)果傳到postResult方法中。下面就在看一下這個postResult方法。

private Result postResult(Result result) {
  @SuppressWarnings("unchecked")
  Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
      new AsyncTaskResult<Result>(this, result));
  message.sendToTarget();
  return result;
}

　　對與這個postResult方法里面也就是在我們子線程的任務(wù)處理完成之后通過一個Handler對象將Message發(fā)送到主線程中，并且交由主線程處理。AsyncTaskResult對象中存放的是子線程返回的結(jié)果以及當(dāng)前AsyncTask對象。下面再看一下這和Handler中所處理了哪些事情。

private static class InternalHandler extends Handler {
  public InternalHandler() {
    super(Looper.getMainLooper());
  }

  @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;
    }
  }
}

　　可以看到在這個Handler的handleMessage中會接受到兩種Message。在MESSAGE_POST_PROGRESS這個消息中主要是通過publishProgress方法將子線程執(zhí)行的進度發(fā)送到主線程中并且通過onProgressUpdate方法來更新進度條的顯示。在MESSAGE_POST_RESULT這個消息中通過當(dāng)前的AsyncTask對象調(diào)用了finish方法，那么就來看一下這個finish方法。

private void finish(Result result) {
  if (isCancelled()) {
    onCancelled(result);
  } else {
    onPostExecute(result);
  }
  mStatus = Status.FINISHED;
}

　　這時候就可以看出若是我們?nèi)∠薃syncTask的話就不在執(zhí)行onPostExecute方法，而是執(zhí)行onCancelled方法，所以我們可以通過重寫onCancelled方法來執(zhí)行取消時我們需要處理的一些操作。當(dāng)然若是AsyncTask沒有被取消，這時候就回執(zhí)行onPostExecute方法。到這里整個AsyncTask任務(wù)也就完成了。

總結(jié)

　　在上面的SerialExecutor線程池中可以看出，當(dāng)有多個異步任務(wù)同時執(zhí)行的時候，它們執(zhí)行的順序是串行的，會按照任務(wù)創(chuàng)建的先后順序進行一次執(zhí)行。如果我們希望多個任務(wù)并發(fā)執(zhí)行則可以通過AsyncTask中的setDefaultExecutor方法將線程池設(shè)為THREAD_POOL_EXECUTOR即可。
　　對于AsyncTask的在不同版本之間的差異不得不提一下。在Android1.6，AsyncTask采用的是串行執(zhí)行任務(wù)，在Android1.6的時候采用線程池處理并行任務(wù)，而在3.0以后才通過SerialExecutor線程池串行處理任務(wù)。在Android4.1之前AsyncTask類必須在主線程中，但是在之后的版本中就被系統(tǒng)自動完成。而在Android5.0的版本中會在ActivityThread的main方法中執(zhí)行AsyncTask的init方法，而在Android6.0中又將init方法刪除。所以在使用這個AsyncTask的時候若是適配更多的系統(tǒng)的版本的話，使用的時候就要注意了。

源碼下載：https://github.com/lijiangdong/asynctask-example

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: