詳細(xì)講解AsyncTask使用說明(值得收藏)
概念
AsyncTask：異步任務(wù)，從字面上來說，就是在我們的UI主線程運行的時候，異步的完成一些操作。AsyncTask允許我們的執(zhí)行一個異步的任務(wù)在后臺。我們可以將耗時的操作放在異步任務(wù)當(dāng)中來執(zhí)行，并隨時將任務(wù)執(zhí)行的結(jié)果返回給我們的UI線程來更新我們的UI控件。通過AsyncTask我們可以輕松的解決多線程之間的通信問題。
怎么來理解AsyncTask呢？通俗一點來說，AsyncTask就相當(dāng)于Android給我們提供了一個多線程編程的一個框架，其介于Thread和Handler之間，我們?nèi)绻x一個AsyncTask，就需要定義一個類來繼承AsyncTask這個抽象類，并實現(xiàn)其唯一的一doInBackgroud 抽象方法。
類簡介
AsyncTask = handler + 兩個線程池的維護一個任務(wù)隊列線程池，一個執(zhí)行線程池
其中：線程池用于線程調(diào)度、復(fù)用 & 執(zhí)行任務(wù)；
Handler用于異步通信
我們來看看AsyncTask這個抽象類的定義，當(dāng)我們定義一個類來繼承AsyncTask這個類的時候，我們需要為其指定3個泛型參數(shù)：
AsyncTask <Params, Progress, Result>
- Params: 這個泛型指定的是我們傳遞給異步任務(wù)執(zhí)行時的參數(shù)的類型
- Progress: 這個泛型指定的是我們的異步任務(wù)在執(zhí)行的時候?qū)?zhí)行的進度返回給UI線程的參數(shù)的類型
- Result: 這個泛型指定的異步任務(wù)執(zhí)行完后返回給UI線程的結(jié)果的類型
簡單例子
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
//忽略
}
public void onClick(View v) {
try {
URL url = new URL("http://blog.csdn.net/");
new DownloadFilesTask().execute(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}執(zhí)行流程
一、在執(zhí)行完 AsyncTask.excute() 后
二、方法分析
常用的AsyncTask繼承的方法有
- onPreExecute()：異步任務(wù)開啟之前回調(diào)，在主線程中執(zhí)行
- doInBackground()：執(zhí)行異步任務(wù)，在線程池中執(zhí)行
- onProgressUpdate()：當(dāng)doInBackground中調(diào)用publishProgress時回調(diào)，在主線程中執(zhí)行
- onPostExecute()：在異步任務(wù)執(zhí)行之后回調(diào)，在主線程中執(zhí)行
- onCancelled()：在異步任務(wù)被取消時回調(diào)
小demo
效果圖：
Activity
public class AsyThreadActivity extends Activity implements View.OnClickListener {
@BindView(R.id.btn_click)
Button btnClick;
@BindView(R.id.progress)
ProgressBar progress;
@BindView(R.id.btn_chancel)
Button btnChancel;
@BindView(R.id.text)
TextView text;
Mythread myasythread = new Mythread();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_asythread);
ButterKnife.bind(this);
initClcik();
}
private void initClcik() {
btnClick.setOnClickListener(this);
btnChancel.setOnClickListener(this);
myasythread.setOntextchance(new Mythread.Ontextchance() {
@Override
public void textchance(String s) {
text.setText(s);
}
@Override
public void progresschance(Integer number) {
progress.setProgress(number);
}
});
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_click:
myasythread.execute();
break;
case R.id.btn_chancel:
myasythread.cancel(true);
break;
default:
break;
}
}
}myAsyncTAsk
public class Mythread extends AsyncTask<String,Integer,String> {
private Ontextchance ontextchance;
public Mythread() {
super();
}
@Override
protected String doInBackground(String... params) {
int count = 0;
while(count<99){
count = count + 1;
publishProgress(count);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}
@Override
protected void onPreExecute() {
ontextchance.textchance("加載中");
super.onPreExecute();
}
@Override
protected void onPostExecute(String s) {
ontextchance.textchance("加載完畢");
super.onPostExecute(s);
}
@Override
protected void onProgressUpdate(Integer... values) {
ontextchance.progresschance(values[0]);
ontextchance.textchance("loading..." + values[0] + "%");
super.onProgressUpdate(values);
}
@Override
protected void onCancelled() {
ontextchance.textchance("已取消");
ontextchance.progresschance(0);
super.onCancelled();
}源碼分析
好吧 ，在想寫之前剛剛好瞄到一位小哥哥的文章寫得超級好，然后我就偷懶一把，如下。
源碼分析是基于API24的源碼，我將會按照下面AsyncTask運行的過程來分析
一、主分支
首先，execute()方法，開啟異步任務(wù)
接著，onPreExecute()方法，異步任務(wù)開啟前
接著，doInBackground()方法，異步任務(wù)正在執(zhí)行
最后，onPostExecute()方法，異步任務(wù)完成
二、次分支
onProgressUpdate()方法，異步任務(wù)更新UI
onCancelled()方法，異步任務(wù)取消
主分支部分
代碼開始的地方，是在創(chuàng)建AsyncTask類之后執(zhí)行的execute()方法
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}execute()方法會調(diào)用executeOnExecutor()方法
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;
}AsyncTask定義了一個mStatus變量，表示異步任務(wù)的運行狀態(tài)，分別是PENDING、RUNNING、FINISHED，當(dāng)只有PENDING狀態(tài)時，AsyncTask才會執(zhí)行，這樣也就保證了AsyncTask只會被執(zhí)行一次
繼續(xù)往下執(zhí)行，mStatus會被標(biāo)記為RUNNING，接著執(zhí)行，onPreExecute()，將參數(shù)賦值給mWorker，然后還有execute(mFuture)
這里的mWorker和mFuture究竟是什么，我們往下追蹤，來到AsyncTask的構(gòu)造函數(shù)中，可以找到這兩個的初始化
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);
}
}
};
}一、分析mWorker
mWorker是一個WorkerRunnable對象，跟蹤WorkerRunnable
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}實際上，WorkerRunnable是AsyncTask的一個抽象內(nèi)部類，實現(xiàn)了Callable接口
二、分析mFuture
mFuture是一個FutureTask對象，跟蹤FutureTask
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}實際上，F(xiàn)utureTask是java.util.concurrent包下的一個類，參數(shù)是個callable，并且將它賦值給FutureTask類中的callable
三、回過頭來看
回到我們AsyncTask初始化mFuture，這里的參數(shù)是mWorker也就不奇怪了，因為mWorker就是一個callable，我們在上面賦值給FutureTask類中的callable就是這個mWorker
mFuture = new FutureTask<Result>(mWorker)
而關(guān)于mWorker和mFuture的初始化早在我們Activity中初始化好了，因為構(gòu)造函數(shù)是跟AsyncTask類的創(chuàng)建而執(zhí)行的
new DownloadFilesTask()
知道了mWorker和mFuture是什么后，我們回到原來的executeOnExecutor()方法，在這里將mWorker的參數(shù)傳過去后，就開始用線程池execute這個mFuture
mWorker.mParams = params; exec.execute(mFuture);
一、分析exec
exec是通過executeOnExecutor()參數(shù)傳進來的
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params)也就是我們execute()方法傳過來的
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}這里可以看到exec就是這個sDefaultExecutor
二、分析sDefaultExecutor
我們跟蹤這個sDefaultExecutor，截取有關(guān)它的代碼
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);
}
}
}從SerialExecutor可以發(fā)現(xiàn)，exec.execute(mFuture)就是在調(diào)用SerialExecutor類的execute(final Runnable r)方法，這里的參數(shù)r就是mFuture
繼續(xù)往下走，SerialExecutor的execute()方法會將r封裝成Runnable，并添加到mTasks任務(wù)隊列中
繼續(xù)往下走，如果這時候沒有正在活動的AsyncTask任務(wù)，那么就會調(diào)用SerialExecutor的scheduleNext()方法，來執(zhí)行下一個AsyncTask任務(wù)
if (mActive == null) {
scheduleNext();
}繼續(xù)往下走，通過mTasks.poll()取出，將封裝在mTask的Runnable交給mActive，最后真正執(zhí)行的這個mActive的是THREAD_POOL_EXECUTOR，即執(zhí)行的這個mActive，也就是包裝在Runnable里面的mFuture
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}mFuture被執(zhí)行了，也就會執(zhí)行它的run()方法
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}我們跟蹤到mFuture的run()方法中，切換到FutureTask類
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);
}
}這一段代碼其實就是將之前在mFutrue創(chuàng)建對象時候傳進來的mWorker交給c
Callable<V> c = callable;
然后再調(diào)用c的call()方法，也就是mWorker的call()方法
result = c.call();
代碼又重新的定位到了mWorker類的call()方法
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);
}
};可以發(fā)現(xiàn)，這里就調(diào)用了我們的doInBackground()方法，最后還返回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;
}觀察代碼，首先是getHandler()，它是一個單例，返回sHandler
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}也就是說postResult方法會通過sHandler發(fā)送一個MESSAGE_POST_RESULT的消息，這個時候我們追蹤到sHandler
private static InternalHandler sHandler;
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;
}
}
}可以發(fā)現(xiàn)，sHandler收到MESSAGE_POST_PROGRESS消息后會調(diào)用result.mTask.finish(result.mData[0])，那么我們還必須知道result是個什么東西
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
result是AsyncTask的內(nèi)部類，實際上就是個實體類，用來存儲變量的
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}result.mTask也就是AsyncTask，最后調(diào)用result.mTask.finish(result.mData[0])，即AsyncTask的finish()方法，我們跟蹤到finish()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}這里判斷AsyncTask是否已經(jīng)取消，如果不取消就執(zhí)行我們的onPostExecute()，最后將狀態(tài)設(shè)置為FINISHED，整一個AsyncTask的方法都執(zhí)行完了，我們只需要繼承AsyncTask實現(xiàn)其中的方法就可以按分析的順序往下執(zhí)行了
次分支部分
在AsyncTask中的finish()方法，我們可以看到onCancelled()方法跟onPostExecute()一起的，只要isCancelled()的值為true，就執(zhí)行onCancelled()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}我們代碼跟蹤isCancelled()方法
public final boolean isCancelled() {
return mCancelled.get();
}發(fā)現(xiàn)是在mCancelled中獲取的，那我們就必須知道這個mCancelled是什么，代碼跟蹤到mCancelled
private final AtomicBoolean mCancelled = new AtomicBoolean();
mCancelled實際上就是個Boolean對象，那我們搜索它是在哪個時候設(shè)置的
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}可以發(fā)現(xiàn)，只要我們在AsyncTask類中調(diào)用這個方法即可停止異步任務(wù)
而onProgressUpdate()方法，是在sHandler中執(zhí)行，sHandler收到MESSAGE_POST_PROGRESS消息后，執(zhí)行，我們搜索MESSAGE_POST_PROGRESS在什么時候發(fā)送的
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;
}
}
}可以發(fā)現(xiàn)，只要我們在AsyncTask類中調(diào)用publishProgress()方法即可執(zhí)行onProgressUpdate()方法
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}源碼原文：https://blog.csdn.net/qq_30379689/article/details/53203556
說實話上面源碼分析寫得真好，我在看了上面的源碼感覺少了一丟丟東西，自己在額外的補充一點東西
補充：THREAD_POOL_EXECUTOR
/**
* 源碼分析：THREAD_POOL_EXECUTOR.execute（）
* 說明：
* a. THREAD_POOL_EXECUTOR實際上是1個已配置好的可執(zhí)行并行任務(wù)的線程池
* b. 調(diào)用THREAD_POOL_EXECUTOR.execute（）實際上是調(diào)用線程池的execute()去執(zhí)行具體耗時任務(wù)
* c. 而該耗時任務(wù)則是步驟2中初始化WorkerRunnable實例對象時復(fù)寫的call（）
* 注：下面先看任務(wù)執(zhí)行線程池的線程配置過程，看完后請回到步驟2中的源碼分析call（）
*/
// 步驟1：參數(shù)設(shè)置
//獲得當(dāng)前CPU的核心數(shù)
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//設(shè)置線程池的核心線程數(shù)2-4之間,但是取決于CPU核數(shù)
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//設(shè)置線程池的最大線程數(shù)為 CPU核數(shù)*2+1
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//設(shè)置線程池空閑線程存活時間30s
private static final int KEEP_ALIVE_SECONDS = 30;
//初始化線程工廠
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());
}
};
//初始化存儲任務(wù)的隊列為LinkedBlockingQueue 最大容量為128
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
// 步驟2： 根據(jù)參數(shù)配置執(zhí)行任務(wù)線程池，即 THREAD_POOL_EXECUTOR
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
// 設(shè)置核心線程池的 超時時間也為30s
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}還有就是 我們可以通過源碼可以知道 使用AsyncTask執(zhí)行的后臺線程只有一個，這個結(jié)局看起來很悲傷。我們原以為執(zhí)行如下。
但是現(xiàn)實是這樣子的
被串行設(shè)置了 如下 synchronized
private static class SerialExecutor implements Executor {
// SerialExecutor = 靜態(tài)內(nèi)部類
// 即 是所有實例化的AsyncTask對象公有的
// SerialExecutor 內(nèi)部維持了1個雙向隊列；
// 容量根據(jù)元素數(shù)量調(diào)節(jié)
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
// execute（）被同步鎖synchronized修飾
// 即說明：通過鎖使得該隊列保證AsyncTask中的任務(wù)是串行執(zhí)行的
// 即 多個任務(wù)需1個個加到該隊列中；然后 執(zhí)行完隊列頭部的再執(zhí)行下一個，以此類推
public synchronized void execute(final Runnable r) {
// 將實例化后的FutureTask類 的實例對象傳入
// 即相當(dāng)于：向隊列中加入一個新的任務(wù)
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();->>分析3
}
}
});
// 若當(dāng)前無任務(wù)執(zhí)行，則去隊列中取出1個執(zhí)行
if (mActive == null) {
scheduleNext();
}
}
// 分析3
protected synchronized void scheduleNext() {
// 1. 取出隊列頭部任務(wù)
if ((mActive = mTasks.poll()) != null) {
// 2. 執(zhí)行取出的隊列頭部任務(wù)
// 即 調(diào)用執(zhí)行任務(wù)線程池類（THREAD_POOL_EXECUTOR）->>繼續(xù)往下看
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}好吧，我到現(xiàn)在還是沒有明白為什么他要如此限制，等哪位小哥哥，知道這個為什么的時候告訴我一聲，拜托拜托
如果我們還是想并行執(zhí)行，參考如下
方法一，繞過 excute 方法避免SerialExecutor 對象
方法二，繞過 excute 方法避免被轉(zhuǎn)換為 自定義線程池
方法三，在excute 方法將默認(rèn)對象換為我們的 自定義線程池對象
//自定義線程池
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 60;
public static final Executor MY_THREAD_POOL_EXECUTOR;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
MY_THREAD_POOL_EXECUTOR = threadPoolExecutor;
} case R.id.btAsyncTaskSerial://串行執(zhí)行
new MyAsyncTask(mActivity, "Task#1 ").execute("123");
new MyAsyncTask(mActivity, "Task#2 ").execute("123");
new MyAsyncTask(mActivity, "Task#3 ").execute("123");
break;
case R.id.btAsyncTaskParallel://并行執(zhí)行 -- 這里使用 AsyncTask 自帶的線程池
new MyAsyncTask(mActivity, "Task#1 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#2 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#3 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
break;
case R.id.btAsyncTaskParallelByUs://并行執(zhí)行 -- 自定義線程池
new MyAsyncTask(mActivity, "Task#1 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#2 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#3 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
break;
case R.id.btAsyncTaskParallelByUs2://并行執(zhí)行 -- 自定義線程池 另外一種方式
MyAsyncTask.setDefaultExecutor(MY_THREAD_POOL_EXECUTOR);//替換掉默認(rèn)的 AsyncTask.SERIAL_EXECUTOR
new MyAsyncTask(mActivity, "Task#a ").execute("abc");
new MyAsyncTask(mActivity, "Task#b ").execute("abc");
new MyAsyncTask(mActivity, "Task#c ").execute("abc");
break;重要的事再次強調(diào)我到現(xiàn)在還是沒有明白為什么他要如此限制，等哪位小哥哥，知道這個為什么的時候告訴我一聲，拜托拜托
Thanks
到此這篇關(guān)于詳細(xì)講解AsyncTask使用說明(值得收藏)的文章就介紹到這了,更多相關(guān)AsyncTask使用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要為大家詳細(xì)介紹了快速創(chuàng)建Android模擬器的方法，感興趣的小伙伴們可以參考一下2016-06-06
這篇文章主要為大家詳細(xì)介紹了RecyclerView實現(xiàn)水波紋點擊效果，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-01-01
這篇文章主要為大家詳細(xì)介紹了Android仿網(wǎng)易云音樂播放界面，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-01-01
這篇文章介紹了Android之RAS加密算法測試實例，有需要的朋友可以參考一下2013-09-09
這篇文章主要介紹了Android開發(fā)之軟鍵盤用法,實例分析了Android軟鍵盤的實現(xiàn)技巧,需要的朋友可以參考下2015-05-05
解決Android Studio一直停留在MyApplication:syncing的問題
這篇文章主要介紹了Android Studio一直停留在MyApplication:syncing的完美解決方案，本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下2020-10-10
這篇文章主要介紹了Android開發(fā)-小技巧篇（集合） 的相關(guān)資料,需要的朋友可以參考下2016-01-01
最近在寫動畫相關(guān)的篇章，經(jīng)常會用到 Curve 這個動畫曲線類，那這個類到底怎么實現(xiàn)的？如果想自己來一個自定義的動畫曲線該怎么弄？本文將為大家詳細(xì)解答2022-04-04
基于Android實現(xiàn)保存圖片到本地并可以在相冊中顯示出來
App應(yīng)用越來越人性化，不僅界面優(yōu)美而且服務(wù)也很多樣化，操作也非常方便。通過本篇文章給大家介紹基于Android實現(xiàn)保存圖片到本地并可以在相冊中顯示出來，對android保存圖片相關(guān)知識感興趣的朋友一起學(xué)習(xí)吧2015-12-12
這篇文章主要為大家詳細(xì)介紹了Android仿微信加載H5頁面進度條，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-06-06