AsyncTask源码分析

骑猪看日落 2022-07-16 06:29 223阅读 0赞

**知识点阅读：**

*  [Android Thread Pool(线程池)的介绍][Android Thread Pool]
 *  [Android AsyncTask的介绍][Android AsyncTask]
 *  [Android FutureTask和Callable的介绍][Android AsyncTask]

--------------------

这里分析的是android 6.0的中AsyncTask源码

*  **AsyncTask源码分析图（画图工底不是很好！）：**
    
    ![这里写图片描述][20161009140556906]
 *  **AsyncTask类分析：**
    
     *  先看线程池配置：对线程池有兴趣，可以阅读[Android Thread Pool(线程池)的介绍][Android Thread Pool]
        
        1.  1 **并行线程池的配置**：  
            这里可以看到，从app启动到app关闭，最多支持Runnable128个,有限的工作队列。

//手机cpu最大支持线程的个数
        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());
            }
        };
        //工作队列，最大个数128
        private static final BlockingQueue<Runnable> sPoolWorkQueue =
                new LinkedBlockingQueue<Runnable>(128);
    
        /** * An {@link Executor} that can be used to execute tasks in parallel. * 多线程并发执行的线程池 */
        public static final Executor THREAD_POOL_EXECUTOR
                = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                        TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

1.  2 **串行线程池的配置：**  
    这里可以看到，AsyncTask默认的线程池是串行的线程池，而串行线程池中runnable最终会执行的并行线程池中。

private static class SerialExecutor implements Executor { 
           //依次存储Runnable
           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);
                }
            }
        }
        public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    
        //AsyncTask默认的线程池，单线程串行的线程池
        private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

**总结：从AsyncTask中线程池看出，不支持并行128个线程的多线程任务，适合小量线程的多线程任务。**

*  **查看Handler的配置：**从源码可知，app中只有一个与AsyncTask相对应的Handler,Handler会执行onProgressUpdate（）或者onPostExecute()。这里产生一个疑问，onPreExecute（）执行在哪里？下面会得到解答。

private static class InternalHandler extends Handler { 
            public InternalHandler() {
                 //主线程的Handler
                super(Looper.getMainLooper());
            }
    
            @SuppressWarnings({
       "unchecked", "RawUseOfParameterizedType"})
            @Override
            public void handleMessage(Message msg) {
                AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
                switch (msg.what) {
                    case MESSAGE_POST_RESULT:
                       //这里会执行AsyncTask中onPostExecute(result)或者 onCancelled(result);
                        // There is only one result
                        result.mTask.finish(result.mData[0]);
                        break;
                    case MESSAGE_POST_PROGRESS:
                        //这里会执行AsyncTask中onProgressUpdate（）
                        result.mTask.onProgressUpdate(result.mData);
                        break;
                }
            }
        }
        private void finish(Result result) {
            if (isCancelled()) {
                onCancelled(result);
            } else {
                onPostExecute(result);
            }
            mStatus = Status.FINISHED;
        } 
       private static InternalHandler sHandler;
       private static Handler getHandler() {
            //单例模式，确保app中只有一个对应的Handler
            synchronized (AsyncTask.class) {
                if (sHandler == null) {
                    sHandler = new InternalHandler();
                }
                return sHandler;
            }
        }

*  **执行execute()方法，代码走向**：  
    从这里可以看出，为什么AsyncTask存在一些注意细节，在这里得到解答

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
            //AsyncTask默认的线程池，和异步执行的参数
            return executeOnExecutor(sDefaultExecutor, params);
     }
     @MainThread
     public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
                Params... params) {
            //这里可以看到AsyncTask创建后，只能执行一次，不然报错
            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;
            //这里可以看出，AsyncTask的execute()只能执行在主线程中
            onPreExecute();
    
            mWorker.mParams = params;
            //默认的线程池（串行线程池）执行任务
            exec.execute(mFuture);//名为mFuture的Runnable，下面接着分析。
            return this;
        }

**总结：若是不用AsyncTask默认的线程池，可以自己配置并发的多线程池或者AsyncTask中的THREAD\_POOL\_EXECUTOR。在调用executeOnExecutor(Executor exec, Params… params)时，传递过去。**

*  **FetureTask中run()代码走向**：  
    上面的exec.execute(mFuture); 这mFuture是一个FetureTask.  
    从源码上可以可以看到，FetureTask中run()执行的Callable的call()方法，和其set()方法

//初始化FetureTask时，传递Callable对象
       public FutureTask(Callable<V> callable) {
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }
        public void run() {
            if (state != NEW ||
                !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
                return;
            try {
                //Callable是一个用于返回结果的任务
                Callable<V> c = callable;
                if (c != null && state == NEW) {
                    V result;
                    boolean ran;
                    try {
                        result = c.call(); //执行Callable中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中call()代码走向**：  
    从源码可知：会执行doInBackground()，执行完后回调在主线程中。

//一个抽象的Callable的实现类，用于返回结果
       private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> { 
            Params[] mParams;
        }
       private final WorkerRunnable<Params, Result> mWorker;
       mWorker = new WorkerRunnable<Params, Result>() {
                //该方法被在FetureTask中run()中回调。
                public Result call() throws Exception {
    
                    mTaskInvoked.set(true);
                    //设置线程优先级，后台级别
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    //这里可以知道doInBackground()是执行在线程池中，即异步执行
                    Result result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                    return postResult(result);
                }
       };
    
       //这里是发送异步执行的结果到主线程的Handler中，进而回调 onPostExecute(result);
       private Result postResult(Result result) {
            @SuppressWarnings("unchecked")
            Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                    new AsyncTaskResult<Result>(this, result));
            message.sendToTarget();
            return result;
        }

**一个AsyncTask内部流程大致已经走完了，实际上源码代码并不止这些，想要了解更多细节，需自行阅读源码。**

*  补充说明：FetureTask中run()还会执行完Callable的call()后，还会执行set().  
    set()方法会执行done(),而done方法会再次确保结果传递到主线程。

protected void set(V v) {
            if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
                outcome = v;
                U.putOrderedInt(this, STATE, NORMAL); // final state
                finishCompletion();
            }
        }
       private void finishCompletion() {
            // assert state > COMPLETING;
            for (WaitNode q; (q = waiters) != null;) {
                if (U.compareAndSwapObject(this, WAITERS, q, null)) {
                    for (;;) {
                        Thread t = q.thread;
                        if (t != null) {
                            q.thread = null;
                            LockSupport.unpark(t);
                        }
                        WaitNode next = q.next;
                        if (next == null)
                            break;
                        q.next = null; // unlink to help gc
                        q = next;
                    }
                    break;
                }
            }
    
            done();//最终会执行这个FutureTask的done()
    
            callable = null;        // to reduce footprint
        }
    
        //done()会回调执行在这里
        private final FutureTask<Result> mFuture;  
         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);
            }
        }

看完这些源码分析后，再去看下AsyncTask源码分析图，脑海里就知道了AsyncTask代码思路。

AsyncTask源码还有，cancle(),get()这些方法的代码走向，但是过程大致都相同，不同的是：get()若是需要等待异步执行结果，会阻塞，直到完成为止。

**最主要的一点：源码是最好的老师，有空得去学学老师的绝技。**

[Android Thread Pool]: http://blog.csdn.net/hexingen/article/details/52087587
[Android AsyncTask]: http://blog.csdn.net/hexingen/article/details/52765337
[20161009140556906]: /images/20220716/9790d8af54ca474b8a09551bca70b67d.png