Android中的多线程之AysncTask原理分析

AsyncTask是一个抽象类，它是由Android封装的一个轻量级异步类，它可以在线程池中执行后台任务，然后把执行的进度和最终的结果传递给主线程并在主线程中更新UI。

首先我们看看它的定义：

public abstract class AsyncTask<Params, Progress, Result>

3种泛型类型分别表示参数类型，后台任务执行的进度类型，返回的结果类型，如果某个参数不需要，可以设置为void。

一个异步任务的执行一般包括以下几个步骤：
- execute（Params… params）：执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。
- onPreExecute（）：在execute方法被调用后立即执行，执行在UI线程，一般用来在执行后台任务之前对UI做一些标记。
- doInBackground（Params… params）：在onPreExecute（）方法完成后立即执行，用于执行较为耗时的操作，此方法将接收输入参数和返回结果计算。在执行过程中可以调用publishProgress（Progress... values）来更新进度信息。
- onProgressUpdate(Progress… values）：执行在UI现在。在调用publishProgress（Progress... values）时，此方法被执行。直接将进度信息更新到UI组件上。
- onPostExecute（Result result）：执行在UI线程。当后台操作结束时，此方法将会被调用，doInBackground方法返回的计算结果将作为参数传递到此方法中，直接将结果显示到UI组件上。

先通过一个下载图片的小例子来体验它：

public class AsyncDemo extends AsyncTask<String,Integer,Bitmap>{


    private String mUrl;
    private onDownLoadInterface mCallback;

    public interface onDownLoadInterface{
        void onStarting();
        void onFinish(Bitmap bitmap);
    }

    public AsyncDemo(onDownLoadInterface callback){
        mCallback = callback;
    }

    @Override
    protected void onPreExecute() {
        mCallback.onStarting();
    }

    @Override
    protected Bitmap doInBackground(String... strings) {
        mUrl =strings[0];
        Bitmap bitmap = null;
        URLConnection connection;
        InputStream in;
        try {

            connection = new URL(mUrl).openConnection();
            in = connection.getInputStream();

            //为了看到效果
            Thread.sleep(2000);

            BufferedInputStream bis =
                    new BufferedInputStream(in);
            bitmap = BitmapFactory.decodeStream(bis);
            in.close();
            bis.close();

        }catch (MalformedURLException e){

            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        mCallback.onFinish(bitmap);
    }
}



         AsyncDemo asyncDemo = new AsyncDemo(this);
        asyncDemo.execute(URL);



    @Override
    public void onStarting() {
        dialog = new AlertDialog.Builder(this)
                .setMessage("图片正在下载")
                .setTitle("下载")
                .create();
        dialog.show();
    }


    @Override
    public void onFinish(Bitmap bitmap) {
        dialog.dismiss();
        mImageView.setImageBitmap(bitmap);
    }

然后我们就可以下载一张图片，效果如图：

这里写图片描述

那么它下载这一张图片，经历了什么呢？

首先我们先看看AsyncTask里面的几个核心的方法：

//执行在工作线程
 @WorkerThread
    protected abstract Result doInBackground(Params... params);

//执行在DoInBackground之前，并且执行在UI线程
 @MainThread
    protected void onPreExecute() {
    }

    // 后台操作执行完会调用的方法，在此更新UI
    @MainThread
    protected void onPostExecute(Result result) {
    }

    //在此更新进度
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }


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

    //执行任务，注意excute方法必须在UI线程中调用
    //exec ：执行任务的线程池
     @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
        //检测状态，只有在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();
        //UI线程，传递过来的参数
        mWorker.mParams = params;
        //交给线程池管理器进行调度，参数为FutureTask类型
        exec.execute(mFuture);

        return this;
    }

    //发布进度
     @WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

在上面代码中，我们看到有一个Stauts的枚举类，Status枚举类代表了AsyncTask的状态：

public enum Status {
        /**
         * 未执行状态
         */
        PENDING,
        /**
         *执行中
         */
        RUNNING,
        /**
         * 执行完成
         */
        FINISHED,
    }

在调用execute方法时，如果是非PENDING状态则会抛出异常，这也就解释了为什么一个AsyncTask实例只能那个运行一次。

在execute方法中，涉及到了三个变量：sDefaultExecutor，mWork，mFuture：

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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

    private static class SerialExecutor implements Executor

sDefaultExecutor：它是ThreadPoolExecutor的实例，用于管理提交给AsyncTask的任务：

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

    //任务队列
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    //线程池
    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;
    }

    //默认的任务调度是顺序执行
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    //顺序执行的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);
            }
        }
    }

从上述代码中我们可以看到，sDefaultExecutor只负责将异步任务分发给THREAD_POOL_EXECUTOR线程池，因此真正执行任务的地方是THREAD_POOL_EXECUTOR。

mWork 和mFuture：

/**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     *
     * @hide
     */
    public AsyncTask(@Nullable Looper callbackLooper) {
        //得到在UI线程中的Handler
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        //WorkRunnable是AsyncTask的一个抽象内部类
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //执行DoInBackground
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //最后将结果投递到UI线程
                    postResult(result);
                }
                return result;
            }
        };
        //mFuture会调用mWork做后台任务，完成后会调用done方法
        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);
                }
            }
        };
    }

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

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


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

我们可以看到在mWork中会通过postResult将结果投递出去，但是如果期间发生了异常，postResult将不会调用，那么最终在Future的done方法中通过postResultIfNotInvoked检查是否执行成功，如果执行成功且未调用postResult，那么就调用postResult，否则忽略该执行结果.

在创建AsyncTask对象后，我们会执行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();

        mWorker.mParams = params;
        //交给线程池管理器来进行调度
        exec.execute(mFuture);
        return this;
    }

//sDefaultExecutor是SerialExecutor实例
private static class SerialExecutor implements Executor {
    //双端队列
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;
        //mFuture实现了Runnable
        public synchronized void execute(final Runnable r) {
            //将Runnable对象放入队列
            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方法接收一个Runnable对象，我们传入的mFuture正好实现了该接口，方法内部首先通过双端队列ArrayDeque的offer方法把一个新创建的Runnable对象入队。然后判断mActive是否为空？第一次执行肯定是为空的，所以会调用scheduleNext方法，scheduleNext方法首先从双端队列中得到一个元素，如果不为空，就调用THREAD_POOL_EXECUTOR.execute方法，THREAD_POOL_EXECUTOR是一个线程池，也就是说我们把从双端队列中得到的任务交给线程池去执行（接下来的代码都在工作线程中执行）

还记得，上面我们看到THREAD_POOL_EXECUTOR是ThreadPoolExecutor的实例（ThreadPoolExecutor实现了Excutor）：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

之前的博客中有分析过这段代码，这段代码的主要功能其实就是将异步任务加入将要执行的队列。

 private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            //得到运行状态和活动线程数
            int c = ctl.get();
            //得到线程池的状态
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                //得到活动线程数
                int wc = workerCountOf(c);
                //boolean类型的core，true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，
               // false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))//检查是否可以新增线程
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);//生成一个Work对象,同时 生成一个新线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);//将w添加到works里，这是一个HashSet集合对象
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {//如果添加成功，就异步执行该任务。在这里就是启动了mFuture任务
                    t.start();//线程启动，那么则会调用到run方法。在这里就是调用了mFuture的run方法
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

     Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

我们可以分析到，线程池在execute一个任务的时候，先是判断是否可以加入任务队列，如果可以，就新建一个线程对任务进行执行，其实也就是调用任务的run方法

public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            //在构造mFuture的时候，传入了一个mWork，也就是callable，
            //mWork是Callable的实例，Callble的call方法是可以返回结果的
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //在这里就是调用mWork的calll方法，得到结果.
                    //在mWork的call方法中，会调用doInBackground方法
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                //如果发送异常
                    result = null;
                    ran = false;
                    //调用setException方法，会调用done方法
                    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);
        }
    }

     mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();//释放
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);//投递结果给UI线程
                }
                return result;
            }
        };


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

 public void sendToTarget() {
        target.sendMessage(this);//target就是Handler
    }


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

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

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

最后，一张流程图附上：
这里写图片描述

分享一张图：

这里写图片描述

Android中的多线程之AysncTask原理分析

猜你喜欢