使用

提供了简单使用线程的方式，必须使用AsyncTask子类，然后调用execute执行任务即可。

AsyncTask<Params, Progress, Result> {
    //在任务执行前调用，在UI线程中运行
    protected void onPreExecute() {
    }
    
    //抽象方法，在工作线程中执行
    protected abstract Result doInBackground(Params... params);
    
    //在UI线程中运行，在任务执行完成后，调用，并返回结果
    protected void onPostExecute(Result result) {
    }
    
    //在UI线程中运行，每次调用返回任务进度
    protected void onProgressUpdate(Progress... values) {
    }
    
    //用于提交任务进度，可以在doInBackground中调用
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
}

源码分析

主要采用 线程池 + handler 的机制， 看一下源码分析

public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";

    //如果看过java 线程池实现的与源码，看到地下这几个参数，应该会很熟悉，这就是线程池子的基本参数
    
    //核心保留的线程数量就一个
    private static final int CORE_POOL_SIZE = 1;
    //运行中最大的线程数量
    private static final int MAXIMUM_POOL_SIZE = 20;
    
    //？？？
    private static final int BACKUP_POOL_SIZE = 5;
    
    //线程空闲之后的存活时间
    private static final int KEEP_ALIVE_SECONDS = 3;
    
    //这个工厂方法就是用来创建线程的
    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 ThreadPoolExecutor sBackupExecutor;
    
    //这是一个任务队列，存储一些，待执行的任务
    private static LinkedBlockingQueue<Runnable> sBackupExecutorQueue;
    
    //这是当任务不能被执行时，调用的处理方法
    private static final RejectedExecutionHandler sRunOnSerialPolicy =
            new RejectedExecutionHandler() {
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            android.util.Log.w(LOG_TAG, "Exceeded ThreadPoolExecutor pool size");
            // As a last ditch fallback, run it on an executor with an unbounded queue.
            // Create this executor lazily, hopefully almost never.
            synchronized (this) {
                if (sBackupExecutor == null) {
                    //创建一个任务队列
                    sBackupExecutorQueue = new LinkedBlockingQueue<Runnable>();
                    
                    //创建一个线程池，用于处理被拒绝的任务
                    sBackupExecutor = new ThreadPoolExecutor(
                            BACKUP_POOL_SIZE, BACKUP_POOL_SIZE, KEEP_ALIVE_SECONDS,
                            TimeUnit.SECONDS, sBackupExecutorQueue, sThreadFactory);
                   //核心线程不超时， 会一直运行，不会终止，即使没有任务
                   sBackupExecutor.allowCoreThreadTimeOut(true);
                }
            }
            
            //执行任务
            sBackupExecutor.execute(r);
        }
    };
    
    //执行任务的（并行）线程池
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        //创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(), sThreadFactory);
                
        //设置一下，任务被拒绝的时候，调用的方法，就是我们上面的sRunOnSerialPolicy 这个东西
        threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
    
    //串行执行的线程池
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    
    //来分析一下，串行线程池的实现
    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);
            }
        }
    }
    
    //这两个应该是消息post出去的code，用来标记的
    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    
    //默认使用的线程池是串行的
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    
    //这个是用于处理从子线程中抛出的数据
    private static InternalHandler sHandler;

    //很明了先直接继承了Handler类    
    private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            //获取抛出的数据，到这里就是UI主线程了
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            
            //开始分类处理不同的数据， 任务结果 或者是 任务进度
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    //调用AsyncTask的finihs接口表示任务结束了
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    //这里是进度的回调
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }
    
    //看一下抛到主线程的数据结构
    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        //包含两个成员变量，一个是任务实例的引用， 一个是抛出的数据
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
    
    //枚举变量，标识任务的状态
    public enum Status {
        /**
         * 指示任务还没执行
         */
        PENDING,
        /**
         * 指示任务开始运行
         */
        RUNNING,
        /**
         * 指示任务执行完成
         */
        FINISHED,
    }
    
    //看一下构造函数    
    public AsyncTask(@Nullable Looper callbackLooper) {
       //从这里可以看到，实际上如果没有指定特定线程的Loop， 使用的是主线程的Loop
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                
                    //设置进程优先级，没看懂， 但是不影响接下来的阅读
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    
                    //执行一下，重载的任务代码
                    result = doInBackground(mParams);
                    
                    //这个也是看不明白，看资料这个代码有可能堵塞线程
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //将结果抛出
                    postResult(result);
                }
                return result;
            }
        };

        //创建一个Future处理一下相应的错误
        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);
                }
            }
        };
    }
    
    //触发任务
     public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        //调用下面的方法executeOnExecutor
        return executeOnExecutor(sDefaultExecutor, params);
    }

    
    //这里算是比较核心的代码了，
    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;
    }
}

总结

高并发的时候，不适合用，毕竟是串行执行的。串行的设计可以借用一下。