使用

提供了簡(jiǎn)單使用線程的方式堪夭，必須使用AsyncTask子類括袒，然后調(diào)用execute執(zhí)行任務(wù)即可毕莱。

AsyncTask<Params, Progress, Result> {
    //在任務(wù)執(zhí)行前調(diào)用蔑鹦，在UI線程中運(yùn)行
    protected void onPreExecute() {
    }
    
    //抽象方法逗概，在工作線程中執(zhí)行
    protected abstract Result doInBackground(Params... params);
    
    //在UI線程中運(yùn)行弟晚，在任務(wù)執(zhí)行完成后，調(diào)用逾苫，并返回結(jié)果
    protected void onPostExecute(Result result) {
    }
    
    //在UI線程中運(yùn)行卿城，每次調(diào)用返回任務(wù)進(jìn)度
    protected void onProgressUpdate(Progress... values) {
    }
    
    //用于提交任務(wù)進(jìn)度，可以在doInBackground中調(diào)用
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
}

源碼分析

主要采用 線程池 + handler 的機(jī)制铅搓， 看一下源碼分析

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

    //如果看過java 線程池實(shí)現(xiàn)的與源碼藻雪，看到地下這幾個(gè)參數(shù)，應(yīng)該會(huì)很熟悉狸吞，這就是線程池子的基本參數(shù)
    
    //核心保留的線程數(shù)量就一個(gè)
    private static final int CORE_POOL_SIZE = 1;
    //運(yùn)行中最大的線程數(shù)量
    private static final int MAXIMUM_POOL_SIZE = 20;
    
    //勉耀？？蹋偏？
    private static final int BACKUP_POOL_SIZE = 5;
    
    //線程空閑之后的存活時(shí)間
    private static final int KEEP_ALIVE_SECONDS = 3;
    
    //這個(gè)工廠方法就是用來創(chuàng)建線程的
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    
        //不要小看這個(gè)原子性的操作便斥，實(shí)際上包含很多并發(fā)的知識(shí)點(diǎn)
        private final AtomicInteger mCount = new AtomicInteger(1);

        //創(chuàng)建一個(gè)線程
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    
    //執(zhí)行被拒絕的時(shí)候，使用的線程池
    private static ThreadPoolExecutor sBackupExecutor;
    
    //這是一個(gè)任務(wù)隊(duì)列威始，存儲(chǔ)一些枢纠，待執(zhí)行的任務(wù)
    private static LinkedBlockingQueue<Runnable> sBackupExecutorQueue;
    
    //這是當(dāng)任務(wù)不能被執(zhí)行時(shí)，調(diào)用的處理方法
    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) {
                    //創(chuàng)建一個(gè)任務(wù)隊(duì)列
                    sBackupExecutorQueue = new LinkedBlockingQueue<Runnable>();
                    
                    //創(chuàng)建一個(gè)線程池黎棠，用于處理被拒絕的任務(wù)
                    sBackupExecutor = new ThreadPoolExecutor(
                            BACKUP_POOL_SIZE, BACKUP_POOL_SIZE, KEEP_ALIVE_SECONDS,
                            TimeUnit.SECONDS, sBackupExecutorQueue, sThreadFactory);
                   //核心線程不超時(shí)晋渺， 會(huì)一直運(yùn)行，不會(huì)終止脓斩，即使沒有任務(wù)
                   sBackupExecutor.allowCoreThreadTimeOut(true);
                }
            }
            
            //執(zhí)行任務(wù)
            sBackupExecutor.execute(r);
        }
    };
    
    //執(zhí)行任務(wù)的（并行）線程池
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        //創(chuàng)建線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(), sThreadFactory);
                
        //設(shè)置一下木西，任務(wù)被拒絕的時(shí)候，調(diào)用的方法随静，就是我們上面的sRunOnSerialPolicy 這個(gè)東西
        threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
    
    //串行執(zhí)行的線程池
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    
    //來分析一下八千，串行線程池的實(shí)現(xiàn)
    private static class SerialExecutor implements Executor {
        //一個(gè)簡(jiǎn)單的任務(wù)隊(duì)列
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        
        //當(dāng)前活躍的任務(wù)
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            //在隊(duì)列尾部添加任務(wù)
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        //運(yùn)行后吗讶，執(zhí)行下一條
                        scheduleNext();
                    }
                }
            });
            
            //當(dāng)前如果沒有活躍的任務(wù)，觸發(fā)一下任務(wù)
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            //從隊(duì)列中獲取一個(gè)任務(wù)
            if ((mActive = mTasks.poll()) != null) {
                //從這里也能看出來實(shí)際上還是借用并行的線程池去運(yùn)行
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }
    
    //這兩個(gè)應(yīng)該是消息post出去的code恋捆，用來標(biāo)記的
    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    
    //默認(rèn)使用的線程池是串行的
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    
    //這個(gè)是用于處理從子線程中拋出的數(shù)據(jù)
    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) {
            //獲取拋出的數(shù)據(jù)照皆，到這里就是UI主線程了
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            
            //開始分類處理不同的數(shù)據(jù)， 任務(wù)結(jié)果 或者是 任務(wù)進(jìn)度
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    //調(diào)用AsyncTask的finihs接口表示任務(wù)結(jié)束了
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    //這里是進(jìn)度的回調(diào)
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }
    
    //看一下拋到主線程的數(shù)據(jù)結(jié)構(gòu)
    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        //包含兩個(gè)成員變量沸停，一個(gè)是任務(wù)實(shí)例的引用膜毁， 一個(gè)是拋出的數(shù)據(jù)
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
    
    //枚舉變量，標(biāo)識(shí)任務(wù)的狀態(tài)
    public enum Status {
        /**
         * 指示任務(wù)還沒執(zhí)行
         */
        PENDING,
        /**
         * 指示任務(wù)開始運(yùn)行
         */
        RUNNING,
        /**
         * 指示任務(wù)執(zhí)行完成
         */
        FINISHED,
    }
    
    //看一下構(gòu)造函數(shù)    
    public AsyncTask(@Nullable Looper callbackLooper) {
       //從這里可以看到愤钾，實(shí)際上如果沒有指定特定線程的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 {
                
                    //設(shè)置進(jìn)程優(yōu)先級(jí)，沒看懂绰垂， 但是不影響接下來的閱讀
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    
                    //執(zhí)行一下室奏，重載的任務(wù)代碼
                    result = doInBackground(mParams);
                    
                    //這個(gè)也是看不明白，看資料這個(gè)代碼有可能堵塞線程
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //將結(jié)果拋出
                    postResult(result);
                }
                return result;
            }
        };

        //創(chuàng)建一個(gè)Future處理一下相應(yīng)的錯(cuò)誤
        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);
                }
            }
        };
    }
    
    //觸發(fā)任務(wù)
     public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        //調(diào)用下面的方法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;
        
        //看一下這里胧沫，使用默認(rèn)的串行線程池去執(zhí)行任務(wù)
        exec.execute(mFuture);

        return this;
    }
}

總結(jié)

高并發(fā)的時(shí)候，不適合用占业，畢竟是串行執(zhí)行的绒怨。串行的設(shè)計(jì)可以借用一下。