學習內容

線程基本概念
線程的不同形式
- AsyncTask
- HandlerThread
- IntentService
線程池基礎

原文開篇部分

主線程主要處理和界面相關的事情，而子線程則往往用于執(zhí)行耗時操作。
線程的多種形態(tài)：
- AsyncTask：底層封裝了線程池和 Handler，目的在于方便開發(fā)者在子線程中更新 UI。
- HandlerThread：底層直接使用了線程，它是一個具有消息循環(huán)的線程，其內部可以使用 Handler
- IntentService：底層直接使用了線程，內部采用 HandlerThread 來執(zhí)行任務，完成后即退出。它是類似后臺線程的服務，不易被系統(tǒng)殺死從而保證后臺任務的執(zhí)行。而單純后臺線程的話，如果內部沒有活動的四大組件，優(yōu)先級低，容易被殺死。
線程池：
- 線程的創(chuàng)建和銷毀有相應的開銷，因此采用線程池，線程池中會緩存一定數量的線程，通過線程池可以避免因為頻繁創(chuàng)建和銷毀線程所帶來的系統(tǒng)開銷。

主線程和子線程

基本介紹

主線程指進程擁有的線程；子線程也叫工作線程，除了主線程以外的線程都是子線程。
主線程的作用是運行四大組件以及處理它們和用戶的交互，而子線程的作用則是執(zhí)行耗時任務。
Android 3.0 以后，網絡訪問必須在子線程中進行，否則網絡訪問會失敗，并拋出 NetworkOnMainThreadException 異常，此舉是為了避免主線程由于被耗時任務所阻塞而出現(xiàn) ANR。

Android 中的線程形態(tài)

AsyncTask

1. 基本

輕量級
適合執(zhí)行后臺任務以及在主線程中訪問 UI，但不適合執(zhí)行特別好使的后臺任務。（特別耗時的，建議線程池）

2.參數

AsyncTask 是一個抽象的泛型類，有三個參數，具體聲明如下

public abstract class AsyncTask<Params, Progress, Result>
Params：表示參數的類型
Progress：表示后臺任務的執(zhí)行進度的類型
Result：表示后臺任務的返回結果的類型

3.核心方法

onPreExecute()：在主線程中執(zhí)行。在異步任務之前調用此方法，做一些準備工作
doInBackground(Params...params)：
1. 在線程池中調用，用于執(zhí)行異步任務，參數表明異步任務的輸入參數。
2. 內部可以通過 publishProgress 方法更新任務進度，而 publishProgress 方法中會調用 onProgressUpdate方法
3. 另外該方法返回結果給 onPostExecute 方法。
onProgressUpdate(Progress...progress)：在主線程中執(zhí)行，當后臺任務的進度發(fā)生改變時此方法被調用。用于更新界面中的進度。
onPostExecute(Result result)：在主線程中執(zhí)行，異步任務執(zhí)行之后，此方法被調用，result 是后臺任務的返回值。用于在任務完成后給出提示。
補充
1. 執(zhí)行順序：onPreExecute --> doInBackground --> onPostExecute。
2. onCanceled()：在 主線程 中執(zhí)行，異步任務取消時，該方法被調用，此時 onPoseExecute 方法不會被調用。

4.限制

AsyncTask 的類必須在 主線程 中加載，即第一次訪問 AsyncTask 必須發(fā)生在主線程，Android 4.1 及以上版本已自動完成。
AsyncTask 的對象必須在 主線程 中創(chuàng)建
execute 方法必須在 UI 線程 調用
不要在程序中直接調用 onPreExecute、doInBackground、onProgressUpdate、onPostExecute 方法
一個 AsyncTask 對象只能 執(zhí)行一次，即只能調用一次 execute 方法，否則報異常
Android 1.6 以前，串行執(zhí)行任務；Android 1.6 時采用線程池處理并行任務；Andorid 3.0 開始，采用單個線程來串行執(zhí)行任務，但是可以通過 AsyncTask 的 executeOnExecutor 方法來并行執(zhí)行任務。

AsyncTask 的工作原理

1.分析

從 execute(Params... params) 入手分析，它會調用 **executeOnExecutor **方法：

@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(&quot;Cannot execute task:&quot;
                            + " 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;
    }

在 executeOnExecutor 方法中，首先 onPreExecute 方法被調用，之后線程池開始執(zhí)行 exec.execute(mFuture)，這里實際上調用的是 SerialExecutor.execute(final Runnable r) 方法：

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

此處可以分析 AsyncTask 的排隊執(zhí)行的過程。首先系統(tǒng)把 AsyncTask 的 Params 參數封裝成 FutureTask 對象，F(xiàn)utureTask 是一個并發(fā)類，它充當 Runnable 的作用。接著這個 FutureTask 會交給 SerialExecutor 的 execute 方法處理。

execute 方法首先會把該 FutureTask 對象插入到任務隊列 mTasks，如果此時沒有正在活動的 AsyncTask 任務，就會執(zhí)行下一個 AsyncTask 任務；同時當一個 AsyncTask 任務執(zhí)行完后，AsyncTask 會繼續(xù)執(zhí)行其他任務直到所有任務都執(zhí)行完為止。（串行執(zhí)行）

AsyncTask 有兩個線程池（THREAD_POOL_EXECUTOR 和 SerialExecutor ）和一個 Handler（InternalHandler）。

SerialExecutor 用于任務的排隊
THREAD_POOL_EXECUTOR 用于真正的執(zhí)行任務
InternalHandler 用于將執(zhí)行環(huán)境從線程池切換到主線程

在上面的分析中，我們看到 SerialExecutor 中調用了 FutrueTask 的 run 方法，而其 run 方法中會調用 mWorker 的 call 方法，call 方法定義在 AsyncTask 的構造函數中

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);
                }
                return result;
            }
        };

能看到，call 方法中首先將 mTaskInvoked 設為 true，表明當前任務已被調用，然后執(zhí)行 AsyncTask 的 doInBackground 方法，接著講返回值傳遞給 postResult 方法，它的實現(xiàn)如下所示：

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

上面的代碼中，postResult 方法會通過 getHandler() 方法得到一個 Handler 對象，然后通過該 Handler 發(fā)送一個消息；實際上 getHandler 返回了一個 mHandler。

private Handler getHandler() {
    return mHandler;
}

而AsyncTask 的構造方法中，對 mHandler 做出如下設置：

mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);


private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

因此實際最后得到的 Handler 對象即為 sHandler，變相要求了 AsyncTask 的類必須在主線程中加載。這個 sHandler 的定義如下：

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

可以看到，sHandler 收到 MESSAGE_POST_RESULT 消息后會調用 AsyncTask 的 finish 方法。

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

如果被取消執(zhí)行，那么調用 onCancelled 方法，否則調用 onPostExecute 方法，此時 doInBackground 的返回值 result 就傳遞給了 onPostExecute 方法。

到此為止，AsyncTask 的整個工作流程就分析完畢了。

2.流程順序

AsyncTask.execute(Params... params) -> AsyncTask.executeOnExecutor(Executor exec,Params... params) （此方法中調用 onPreExecute）-> SerialExecutor.execute(final Runnable r) -> FutureTask r.run() -> WorkerRunnable<Params,Result> mWorker.call()(此方法中調用 doInBackground） -> AsyncTask.postResult(Result result) -> sHandler 發(fā)送消息 -> InternalHandler.handleMessage -> AsyncTask.finish（此方法中調用 onCancelled 或者 onPostExecute ）

HandlerThread

介紹

HandlerThread 繼承了 Thread，是一種可以使用 Handler 的 Thread。
實現(xiàn)簡單：在 run 方法中通過 Looper.prepare() 來創(chuàng)建消息隊列，并通過 Looper.loop() 開啟消息循環(huán)，這樣就可以創(chuàng)建使用 Handler 了。
HandlerThread vs. 普通的 Thread：
1. 普通 Thread 主要用于在 run 方法中執(zhí)行一個耗時任務;
2. HandlerThread 在內部創(chuàng)建了消息隊列，外界需要通過 Handler 的消息方式來通知 HandlerThread 執(zhí)行一個具體的任務
使用場景之一：IntentService
建議：和 Looper 類似，當明確不再需要 HandlerThread 時，通過它的 quit 或者 quitSafely 方法來終止線程的執(zhí)行。

IntentService

1.介紹

IntentService 是一種特殊的 Service，繼承了 Service 并且是一個 抽象類。
用于執(zhí)行后臺耗時的任務，任務執(zhí)行后它會自動停止。同時因為其本質是 Service，導致優(yōu)先級比普通的線程高，不容易被殺死，所以適合執(zhí)行一些 高優(yōu)先級的后臺任務。

2.原理

IntentService 封裝了 HandlerThread 和 Handler，從源碼中可以清楚的看到：

public abstract class IntentService extends Service {
    //...
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }
    
    @Override
    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    
    //...
}

在第一次啟動 IntentService 時，onCreate 方法創(chuàng)建一個 HandlerThread，然后利用 Looper 來構造一個 Handler 對象 mServiceHandler，這樣通過 mServiceHandler 發(fā)送的消息最后都會在 HandlerThread 中執(zhí)行。

當每次啟動 IntentService 時，都會調用 onStartConmmand 方法，而其又會調用 onStart 方法，源碼如下：

@Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

@Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

可以看出，它只是通過 mServiceHandler 發(fā)送了一條消息，這條消息包含了 Intent 對象，這個消息會在 HandlerThread 中處理。當 mServiceHandler 收到消息后，會將 Intent 對象傳遞給 onHandleIntent 方法，而 onHandleIntent 方法是一個抽象方法，通過子類重寫該方法從而實現(xiàn)通過 Intent 對象解析外界啟動 IntentService 時傳入的參數，并針對不同參數區(qū)分具體的后臺任務。

@WorkerThread
protected abstract void onHandleIntent(@Nullable Intent intent);

當 onHandlerIntent 結束后，就會調用 stopSelf(int startId) 方法停止服務，該方法會等待所有的消息都處理完畢后才會終止服務。（stopSelf()方法會立即終止）

作為補充，IntentService 是順序執(zhí)行后臺任務的，原因在于 IntentService 內部是通過消息的方式向 HandlerThread 請求執(zhí)行任務，而 Handler 的 Looper 是順序處理的，因此 IntentService 也是順序執(zhí)行的。

Android 中的線程池

線程池的優(yōu)點：

重用線程池中的線程，避免因為線程的創(chuàng)建和銷毀所帶來的性能開銷
有效控制線程池的最大并發(fā)數，避免大量的線程之間因互相搶占系統(tǒng)自ui按導致的阻塞現(xiàn)象
能夠對線程進行簡單的管理，并提供定時指定以及指定間隔循環(huán)執(zhí)行等功能。

1.ThreadPoolExecutor

1.基本介紹

該類是線程池的真正實現(xiàn)，Android 的線程池都是直接或者間接通過配置 ThreadPoolExecutor 來實現(xiàn)的。
一個比較常用的構造方法：
```
public ThreadPoolExector(int corePoolSize,
                        int maximunPoolSize,
                         long keepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue,
                         ThreadFactory threadFactory)
```
參數說明：
- corePoolSize：線程池的核心線程數，默認情況下，核心線程會一直存活。如果設置 allowCoreThreadTimeOut 為 true，且等待時間超過 keepAliveTime 所制定的時長后，核心線程會被終止。
- maximunPoolSize：線程池能容納的最大線程數，當活動的線程達到這個數值之后，后續(xù)任務會被阻塞。
- keepAliveTime：非核心線程閑置時的超時時長，超過這個時長，非核心線程就會被回收。當設置 allowCoreThreadTimeOut = true 時，同樣會作用于核心線程。
- unit：指定 keepAliveTime 參數的時間單位，這是一個枚舉。
- workQueue：線程池中的任務隊列，通過線程池的 execute 方法提交的 Runnable 對象會存儲在這個參數中。
- threadFactory：線程工廠，為線程池提供創(chuàng)建新線程的功能功能。它是個接口，只有一個方法：Thread newThread(Runnable r)
不常用的參數
- RejectedExecutionHandler handler：當線程池無法執(zhí)行新任務時，可能是由于任務隊列已滿或者時無法成功執(zhí)行任務，此時 ThreadPoolExecutor 會調用 handler 的 rejectdExecution 方法來通知調用者。

2.執(zhí)行任務的規(guī)則

線程池中的線程數量未達到核心線程的數量：直接啟動一個核心線程來執(zhí)行任務。
如果線程池中的線程數量已經大導或者超過核心線程的數量，那么任務會被插入到任務隊列等待執(zhí)行
如果 2 中無法將任務插入到任務隊列中，這往往是由于任務隊列已滿，此時如果線程數量未達到線程池規(guī)定的最大值，那么會立刻啟動一個非核心線程來執(zhí)行任務。
如果 3 中線程數量已經達到線程池規(guī)定的最大值，那么據拒絕執(zhí)行此任務，此時上述不常用的參數 handler 發(fā)揮作用。

3.AsyncTask 線程池的配置

（針對 THREAD_POOL_EXECUTOR 線程池）

核心線程數等于 CPU 核心數 + 1
線程池的最大線程數為 CPU 核心數的 2 倍 + 1
核心線程無超時機制，非核心線程在閑置時的超時時間為 1 秒
任務隊列的容量為 128

2.線程池的分類

常見的 4 個線程池

FixedThreadPool
1. 線程池固定的線程池，當線程處于空閑狀態(tài)時，它們并不會被回收，除非線程池被關閉。當所有的線程都處于活動狀態(tài)時，新任務都會處于等待狀態(tài)，直到有線程空閑出來。
2. 只有核心線程并且不會被回收，能夠更加快速的響應外界的請求。
CachedThreadPool
1. 線程數量不定的線程池，只有非核心線程，最大線程數為 Integer.MAX_VALUE。
2. 當線程池中的線程都處于活動狀態(tài)時，線程池會創(chuàng)建新的線程來處理新任務，否則利用空閑的線程來處理新任務。線程池中的空閑線程具有超時機制，為 60s。
3. 任務隊列相當于一個空集合，導致任何任務都會立即被執(zhí)行，適合執(zhí)行大量耗時較少的任務。當整個線程池都處于限制狀態(tài)時，線程池中的縣城都會超時而被停止。
ScheduledThreadPool
1. 核心線程數量固定，非核心線程數沒有限制，并且非核心線程閑置的時候立即回收。
2. 主要用于執(zhí)行定時任務和具有固定周期的重復任務
SingleThreadExecutor
1. 只有一個核心線程，保證所有的任務都在一個線程中順序執(zhí)行。
2. 意義在于不需要處理線程同步的問題。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Android 開發(fā)藝術探索筆記之十一 -- Android 的多線程和線程池

Android 開發(fā)藝術探索筆記之十一 -- Android 的多線程和線程池

主線程和子線程

Android 中的線程形態(tài)

AsyncTask

AsyncTask 的工作原理

HandlerThread

IntentService

Android 中的線程池

1.ThreadPoolExecutor

2.線程池的分類

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Android 開發(fā)藝術探索筆記之十一 -- Android 的多線程和線程池

主線程和子線程

Android 中的線程形態(tài)

AsyncTask

AsyncTask 的工作原理

HandlerThread

IntentService

Android 中的線程池

1.ThreadPoolExecutor

2.線程池的分類

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频