Android中的AsyncTask

AsyncTask有两种运行的方式，串行和并行。

以下是我做的一个测试例子有串行和并行，代码如下，可以看到两种方式的不同。

package com.example.xueqin.asynctaskdemo;import android.app.Activity;import android.os.AsyncTask;import android.os.Bundle;import android.support.annotation.Nullable;import android.view.View;import android.widget.Button;import android.widget.ProgressBar;/** * Created by xue.qin on 2017/6/12. */public class MainActivity extends Activity implements View.OnClickListener {    Button button;    ProgressBar progressBar1, progressBar2, progressBar3, progressBar4;    Integer[] params = {0, 1, 2, 3};    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main_activity_layout);        progressBar1 = (ProgressBar) findViewById(R.id.progressbar1);        progressBar2 = (ProgressBar) findViewById(R.id.progressbar2);        progressBar3 = (ProgressBar) findViewById(R.id.progressbar3);        progressBar4 = (ProgressBar) findViewById(R.id.progressbar4);        button = (Button) findViewById(R.id.start);        button.setOnClickListener(this);    }    @Override    public void onClick(View v) {        MyAsyncTask myAsyncTask1 = new MyAsyncTask();        MyAsyncTask myAsyncTask2 = new MyAsyncTask();        MyAsyncTask myAsyncTask3 = new MyAsyncTask();        MyAsyncTask myAsyncTask4 = new MyAsyncTask();        //并行调用        myAsyncTask1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 0);        myAsyncTask2.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 1);        myAsyncTask3.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 2);        myAsyncTask4.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 3);        //串行调用//        myAsyncTask1.execute(0);//        myAsyncTask2.execute(1);//        myAsyncTask3.execute(2);//        myAsyncTask4.execute(3);    }    class MyAsyncTask extends AsyncTask<Integer, Integer, String> {        private int index = 0;        @Override        protected String doInBackground(Integer... params) {            index = params[0];            int increase = 0;            while (increase <= 100) {                try {                    Thread.sleep(50);                } catch (InterruptedException e) {                    e.printStackTrace();                }                publishProgress(increase++);            }            return "complete";        }        @Override        protected void onProgressUpdate(Integer... values) {            switch (index) {                case 0:                    progressBar1.setProgress(values[0]);                    break;                case 1:                    progressBar2.setProgress(values[0]);                    break;                case 2:                    progressBar3.setProgress(values[0]);                    break;                case 3:                    progressBar4.setProgress(values[0]);                    break;                default:                    break;            }        }    }}

并行调用：进度条是一起滚动的，如图

串行调用时依次进行的如图

源码分析。

1）第一种，串行调用，使用默认的线程池，来运行，调用下面的这个函数

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

接着调用这个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;    }

这里没什么说的，这个mFuture是在无参数的构造函数（必会被调用）中将我们重写的doInBackground(),包装成WorkerRunnable，又包了一层变成了FutureTask。

总之提交这个mFuture到线程池中执行，就会调用doInBackground（）里的代码。

看一下这个sDefaultExecutor执行的代码：

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

这里的逻辑应该是这样的，当第一次执行execute()时，mActive==null，执行scheduleNext(), 这里将Runnable提交到线程池运行，运行之后finnally继续调用scheduleNext()直到mTasks中没有runnable，所以是串行执行的。

这样的好处：

连续执行execute，只在第一次，开始scheduleNext(),之后自动调用，这中间，还是可以不断的向mTask中添加Runable，也就是说总会排队执行完所用的execute的runnable。

执行完成之后，下一次提交又是进入下一个循环。

scheduleNext为什么加锁：因为主线程和线程池都会调用到这个函数，不加锁，可能会重复调用，那么就有可能有并行的情况出现。ArrayDeque也不是线程安全的，会出现runnable重复执行等很多问题。同理execute也是因为ArrayDeque线程的不安全，可能会有在同一个index提交两个runnable,之前的就被顶掉了，等各种情况出现。

2）并行调用。

直接使用上面提到的executeOnExecutor这个函数，自定义线程池来调用。AsyncTask中已经写好了一个线程池，如下：

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);        threadPoolExecutor.allowCoreThreadTimeOut(true);        THREAD_POOL_EXECUTOR = threadPoolExecutor;    }

并使用静态块初始化了这个线程池。可以使用以下代码来使用这个线程池来调用，这个自然就是并行的了。

myAsyncTask1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 0);        myAsyncTask2.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 1);        myAsyncTask3.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 2);        myAsyncTask4.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 3);