Android中的AsyncTask

超、凢脫俗 2022-06-14 06:41 227阅读 0赞

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

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

![Center][]

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

![Center 1][]

源码分析。

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

[Center]: /images/20220614/9a17185e1d7a484d9743d10bfd86c97e.png
[Center 1]: /images/20220614/0e468dc6df064998a024ed6e37b8a3da.png