Android AsyncTask 深度理解、简单封装、任务队列分析、自定义线程池
?
1、概念
? ? Android 中的異步任務常用的一種方式是：Handler + Thread 組合來實現的。Thread 負責子線程的耗時操作，Handler 負責線程間的通信，用的最多的當屬子線程和主線程通信。
? ? Android 為了簡化操作，提供了 AsyncTask 類來實現異步任務，并且輕松實現子線程和主線程間的通信。
2、AsyncTask的簡單封裝
? ? 三個參數代表的含義
- Params：第一個參數是啟動任務傳進來的參數；
- Progress：第二個參數是用來顯示進度條的參數；
- Result：第三個參數是后臺執行后返回的參數的類型。
?
3、簡單的異步任務使用
package com.app;import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.util.Log; import wifi.app.wei.com.myapplication.R;public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);new MyTask<String>().setTaskListener(new MyTask.TaskListener() {@Overridepublic void start() {Log.d( "task--" , "start 開始了， 運行在主線程" ) ;}@Overridepublic void update(int progress) {}@Overridepublic Object doInBackground(Object o) {Log.d( "task--" , "doInBackground ， 運行在子線程" ) ;return null;}@Overridepublic void result(Object o) {Log.d( "task--" , "result ， 運行在主線程" ) ;}}).execute( "" ) ;} }
4、帶有進度更新的異步任務使用
package com.app;import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.util.Log; import android.widget.TextView;import wifi.app.wei.com.myapplication.R;public class MainActivity extends AppCompatActivity {private TextView textView ;private MyTask myTask ;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);textView = (TextView) findViewById( R.id.tv1 );myTask = new MyTask<String>().setTaskListener(new MyTask.TaskListener() {@Overridepublic void start() {Log.d( "task--" , "start 開始了， 運行在主線程" ) ;textView.setText( "任務開始了" );}@Overridepublic void update(int progress) {textView.setText( "進度" + progress );}@Overridepublic Object doInBackground(Object o) {Log.d( "task--" , "doInBackground ， 運行在子線程" ) ;for ( int i = 0 ; i < 100 ; i++ ){try {Thread.sleep( 100 ) ;myTask.updateProgress( i ) ; //每隔100毫秒，更新一下進度} catch (InterruptedException e) {e.printStackTrace();}}return "結束了";}@Overridepublic void result(Object o) {Log.d( "task--" , "result ， 運行在主線程" ) ;textView.setText( "" + o );}}) ;//開始執行任務myTask.execute( "" ) ;} }執行效果圖
?
5、AsyncTask 任務執行應該注意的細節
(1)、如果異步任務需要聯網，則需要添加聯網權限
? ? ? ? ? ? ?<uses-permission android:name="android.permission.INTERNET"/>
? ? ? (2)、AsyncTask實例必須在UI線程中創建，execute(Params…)方法必須在UI線程中調用。不用手動調用onPreExecute()。
? ? ?(3)、一個任務只能被執行一次
?
6、如何取消任務
? ? ?可以調用 myTask.cancle() ; ?
? ? ?但是這個方法并沒有真正的結束任務，只是設置了一個標志位，把當前線程中斷了。
? ? ?取消任務實踐
package com.app;import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.util.Log; import android.view.View; import android.widget.TextView; import wifi.app.wei.com.myapplication.R;public class MainActivity extends AppCompatActivity {private TextView textView ;private MyTask myTask ;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);textView = (TextView) findViewById( R.id.tv1 );textView.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {//取消任務myTask.cancle();}});myTask = new MyTask<String>().setTaskListener(new MyTask.TaskListener() {@Overridepublic void start() {Log.d( "task--" , "start 開始了， 運行在主線程" ) ;textView.setText( "任務開始了" );}@Overridepublic void update(int progress) {textView.setText( "進度" + progress );}@Overridepublic Object doInBackground(Object o) {Log.d( "task--" , "doInBackground ， 運行在子線程" ) ;for ( int i = 0 ; i < 100 ; i++ ){try {Thread.sleep( 100 ) ;myTask.updateProgress( i ) ; //每隔100毫秒，更新一下進度} catch (InterruptedException e) {e.printStackTrace();}}return "結束了";}@Overridepublic void result(Object o) {Log.d( "task--" , "result ， 運行在主線程" ) ;textView.setText( "" + o );}}) ;//開始執行任務myTask.execute( "" ) ;} }當點擊textView時，調用了 myTask.cancle() ;方法后，Android studio 控制臺拋出了異常
?
通過這里我們發現，AsyncTask 雖然提供了cancle( true ) ?方法來停止任務，但是這個方法只是中斷了這個線程，但是并不能真正意思上的停止任務，這也是很多人說 AsyncTask 的弊端。極容易造成內存溢出的。
?
幾種結束任務的間接實現方式：
1、判斷標志位的辦法：
我們要知道在java的線程中，沒有辦法停止一個正在運行中的線程。在Android的AsyncTask中也是一樣的。如果必須要停止一個線程，我們可以采用這個線程中設置一個標志位，然后在線程run方法或AsyncTask的doInBackground方法中的關鍵步驟判斷這個標志位以決定是否繼續執行。然后在需要終止此線程的地方改變這個標志位以達到停止線程的目的。
2、合理的利用Exception
從外部調用AsyncTask的cancel方法并不能停止一個已經啟動的AsyncTask。這個cancel方法的作用與線程的interrupt方法相似，調用了一個線程的interrupt方法之后線程仍然運行，但是如果該線程的run方法里面調用過sleep的或者wait方法后，處于sleep或wait狀態，則sleep和wait立即結束并且拋出InterruptedException異常。AsyncTask的cancel方法也一樣，如果在這個Task的doInBackground方法中調用了sleep或wait方法，當在UI線程中調用了這個Task實例的cancel方法之后，sleep或wait立即結束并且拋出InterruptedException異常，但是如果捕獲該異常的代碼后面還有其他代碼，則這些代碼還會繼續執行。
3、可以在UI上做手腳
如果用戶在后臺線程正獲取內容時做出了取消的行為，我們可以根據用戶的這種行為在UI上立即做出反饋，此時，即使線程完成了數據的Loading，我們也不讓數據顯示出來，算是一種投機取巧的辦法吧。
7、AsyncTask 串行處理任務 和 并行處理任務
? ? ?在上面的代碼演示中，執行任務用的都是 myTask.execute() , 這個默認是串行執行任務的。比如同一時刻有兩個任務要處理，AsyncTask 會先執行第一個任務，等第一個任務執行結束，然后才會執行第二個任務。
? ? ?在AsyncTask中還有一個并行處理任務的方法：executeOnExecutor(?Executor exe ,?Params... params ) 。?
?
? ? ?下面是串行執行任務execute()的源碼
? ? ?
?
? 通過看源碼，發現其實串行執行任務也是調用了并行的方法?executeOnExecutor?() , 只不過啟用了一個默認的?sDefaultExecutor （sDefaultExecutor 是一個串行的線程池）。
? 有串行線程池，那么勢必就有一個并行線程池 , 在AsyncTask里面源碼里面定義了一個并行線程池：?THREAD_POOL_EXECUTOR 。
??
? ? ? ?可以看到并行?THREAD_POOL_EXECUTOR 是通過 new?ThreadPoolExecutor() 來創建的
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory) {this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,threadFactory, defaultHandler);}參數說明：
corePoolSize： 線程池維護線程的最少數量?
maximumPoolSize：線程池維護線程的最大數量
keepAliveTime： 線程池維護線程所允許的空閑時間
unit： 線程池維護線程所允許的空閑時間的單位
workQueue： 線程池所使用的緩沖隊列
handler： 線程池對拒絕任務的處理策略
?
我們知道，受限于硬件、內存和性能，我們不可能無限制的創建任意數量的線程，因為每一臺機器允許的最大線程是一個有界值。也就是說ThreadPoolExecutor管理的線程數量是有界的。線程池就是用這些有限個數的線程，去執行提交的任務。然而對于多用戶、高并發的應用來說，提交的任務數量非常巨大，一定會比允許的最大線程數多很多。為了解決這個問題，必須要引入排隊機制，或者是在內存中，或者是在硬盤等容量很大的存儲介質中。J.U.C提供的ThreadPoolExecutor只支持任務在內存中排隊，通過BlockingQueue暫存還沒有來得及執行的任務。
任務的管理是一件比較容易的事，復雜的是線程的管理，這會涉及線程數量、等待/喚醒、同步/鎖、線程創建和死亡等問題。ThreadPoolExecutor與線程相關的幾個成員變量是：keepAliveTime、allowCoreThreadTimeOut、poolSize、corePoolSize、maximumPoolSize，它們共同負責線程的創建和銷毀。
corePoolSize：
線程池的基本大小，即在沒有任務需要執行的時候線程池的大小，并且只有在工作隊列滿了的情況下才會創建超出這個數量的線程。這里需要注意的是：在剛剛創建ThreadPoolExecutor的時候，線程并不會立即啟動，而是要等到有任務提交時才會啟動，除非調用了prestartCoreThread/prestartAllCoreThreads事先啟動核心線程。再考慮到keepAliveTime和allowCoreThreadTimeOut超時參數的影響，所以沒有任務需要執行的時候，線程池的大小不一定是corePoolSize。
maximumPoolSize：
線程池中允許的最大線程數，線程池中的當前線程數目不會超過該值。如果隊列中任務已滿，并且當前線程個數小于maximumPoolSize，那么會創建新的線程來執行任務。這里值得一提的是largestPoolSize，該變量記錄了線程池在整個生命周期中曾經出現的最大線程個數。為什么說是曾經呢？因為線程池創建之后，可以調用setMaximumPoolSize()改變運行的最大線程的數目。
poolSize：
線程池中當前線程的數量，當該值為0的時候，意味著沒有任何線程，線程池會終止；同一時刻，poolSize不會超過maximumPoolSize。
keepAliveTime
當線程空閑時間達到keepAliveTime，該線程會退出，直到線程數量等于corePoolSize。如果allowCoreThreadTimeout設置為true，則所有線程均會退出直到線程數量為0。
? ? ?
了解了各個參數的含義之后，我們來看看 AsyncTask 中默認的并行線程隊列?THREAD_POOL_EXECUTOR 各項的數值
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());} };private static final BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(128);- corePoolSize 為cup數加 1 ?; ? ? ??
- maximumPoolSize 為cup數的2倍加1
- 存活時間為1秒
- 任務緩存隊列為 LinkedBlockingQueue
???
? ? ?小測試：我手上的手機是聯想 k50-t5 , ?在設置里面看到處理器為 8 核1.7GHZ ， 運行?Runtime.getRuntime().availableProcessors(); 方法得到的值為：8 。
? ? ?另外我們也可以總結出：
- ?同一臺手機上，THREAD_POOL_EXECUTOR 的?corePoolSize 和?maximumPoolSize 的值是固定的。
- ?在不同的手機上，THREAD_POOL_EXECUTOR 的?corePoolSize 和?maximumPoolSize 的值是不同的。 這種動態設置的方法值得我們學習，在不同的設備上所使用的策略是不同的。但是也是方式也是有弊端的，任務并發數是由cpu的限定的，不可人為的修改。
?
總結：
//開始執行 串行任務myTask.execute( "" ) ;或者myTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR , "" ) ;//開始執行 并行任務myTask.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR , "" ) ;?
?8、自定義線程池
?上一部分我們已經明白了AsyncTask 的默認并行線程池?THREAD_POOL_EXECUTOR 是通過 new?ThreadPoolExecutor() 來創建的 ， 那么我們也可以自己定義一個線程池。
? ? ? ? 首先來看?ThreadPoolExecutor 的構造函數
? ? ? ??
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue) {this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);}public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory) {this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,threadFactory, defaultHandler);}public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler) {this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), handler);}public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)throw new IllegalArgumentException();if (workQueue == null || threadFactory == null || handler == null)throw new NullPointerException();this.corePoolSize = corePoolSize;this.maximumPoolSize = maximumPoolSize;this.workQueue = workQueue;this.keepAliveTime = unit.toNanos(keepAliveTime);this.threadFactory = threadFactory;this.handler = handler;}? 通過看構造方法，發現?corePoolSize 、maximunPoolSize 、keepAliveTime 、unit 、workQueue 是必須要寫的。
? 分析最后一個構造
if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)throw new IllegalArgumentException();corePoolSize ：最小值 0?
? ? ?maximunPoolSize ：最小值 1
? ? ??corePoolSize 必須小于或者等于?maximunPoolSize?
?
? ? 主要來看 workQueue , 這個是就是線程隊列了。
? ? 下面是AsyncTask并行線程池?THREAD_POOL_EXECUTOR 里面所使用的線程隊列，128 代表線程隊列的長度
private static final BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(128);? ? ?下面給出一個完整的例子：
?
//創建緩沖隊列 隊列長度：100BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(100);//創建線程池 核心線程：5個 最大線程：10個 線程空閑存活時間：1秒Executor executor = new ThreadPoolExecutor( 5 , 10 , 1 , TimeUnit.SECONDS ,sPoolWorkQueue ) ;//添加任務到緩沖隊列myTask1.executeOnExecutor( executor , "" ) ;
線程創建規則
一個任務通過 execute(Runnable)方法被添加到線程池，任務就是一個 Runnable類型的對象，任務的執行方法就是 Runnable類型對象的run()方法。
當一個任務通過execute(Runnable)方法欲添加到線程池時：
?1、 ?如果此時線程池中的數量小于corePoolSize，即使線程池中的線程都處于空閑狀態，也要創建新的線程來處理被添加的任務。
?2、 ?如果此時線程池中的數量等于 corePoolSize，但是緩沖隊列 workQueue未滿，那么任務被放入緩沖隊列。
?3、 ?如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量小于maximumPoolSize，建新的線程來處理被添加的任務。
?4、 ?如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務。也就是：處理任務的優先級為：核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。
?5、 ?當線程池中的線程數量大于 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態的調整池中的線程數。
?
線程池按以下行為執行任務
?
任務隊列執行的邏輯：
? ? FIFO ?先進先出?
?
9、自定義線程池的簡便方法
? ? ? 在第8節我們詳解了如何自定義線程池，講解了?ThreadPoolExecutor 構造方法的每個參數的用法，但是如果自定義線程池都要寫那么多參數，豈不是很麻煩。
? ? ?幸運的是，系統的?java.util.concurrent 包下面?Executors 類提供了很多簡單的方法，供我們使用，這對苦逼的碼農來說，是很好的福音。
? ? ? Executors?里面的方法有?
public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory);}public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}public static ExecutorService newWorkStealingPool(int parallelism) {return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);}public static ScheduledExecutorService newSingleThreadScheduledExecutor() {return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));}public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory));}public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1, threadFactory));}public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>(),threadFactory);}public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);}public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);}猛一看，方法那么多，其實把方法單獨領出來
public static ExecutorService newFixedThreadPool(int nThreads)public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)public static ExecutorService newSingleThreadExecutor()public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)public static ExecutorService newWorkStealingPool() public static ExecutorService newWorkStealingPool(int parallelism)public static ScheduledExecutorService newSingleThreadScheduledExecutor()public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) public static ExecutorService newCachedThreadPool()public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)public static ScheduledExecutorService newScheduledThreadPool ( int corePoolSize, ThreadFactory threadFactory)這樣一歸類，就清晰很多了，就12個方法，然后每2個方法又可以歸為一組，也就是6組。
? ? ?9.1、 newFixedThreadPool(int nThreads) ?創建固定大小的線程池
| public static ExecutorService newFixedThreadPool(int nThreads) public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) |
? ? ? 這兩個函數用于創建一個最大線程數目固定的線程池，該線程池用一個共享的無界隊列來存儲提交的任務。參數nThreads指定線程池的最大線程數，參數threadFactory是線程工廠類，主要用于自定義線程池中創建新線程時的行為。需要說明的是，創建線程池時，如果線程池沒有接收到任何任務，則線程池中不會創建新線程，在線程池中線程數目少于最大線程數時，每來一個新任務就創建一個新線程，當線程數達到最大線程數時，不再創建新線程，新來的任務存儲在隊列中，之后線程數目不再變化！
創建一個線程數量固定大小，任務隊列無限大的線程池。當隊列中需要的線程數超出定義的線程的時候，所有任務將在隊列中排隊，等待空閑線程執行。? ? ?
public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}
? ? 9.2、?newSingleThreadExecutor ?創建只有一個線程的線程池，其實就相當于串行線程池? ? ? ? ?
? ? ? ? ? ? ??線程池中的任務使用無界隊列存儲，第二個函數可以指定threadFactory，自定義創建線程時的行為。
public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}? ??
? ? ?9.3、newWorkStealingPool
? ? ? ? ? ? ??這個方法用于創建ForkJoin框架中用到的ForkJoinPool線程池，第一個函數中的參數用于指定并行數，第二個函數沒有參數，它默認使用當前機器可用的CPU個數作為并行數。
public static ExecutorService newWorkStealingPool() {return new ForkJoinPool(Runtime.getRuntime().availableProcessors(),ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);}
? ? ?9.4 、?newSingleThreadScheduledExecutor
? ? ? ? ? ?該方法用于創建只有一個線程的線程池，并且該線程定時周期性地執行給定的任務
? ? ? ? ? ?需要注意的是:?線程在周期性地執行任務時如果遇到Exception，則以后將不再周期性地執行任務。
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));}
? ? ?9.5、newCachedThreadPool
? ? ??方法用于創建線程數數目可以隨著實際情況自動調節的線程池，也有兩種類型的函數簽名：
| public static ExecutorService newCachedThreadPool() public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) |
? ? ?這種線程池的最大線程數只受到操作系統可以創建的最大線程數數目限制，當線程池有很多任務需要處理時，會不斷地創建新線程，當任務處理完畢之后，如果某個線程空閑時間大于60s，則該線程將會被銷毀。因為這種線程池能夠自動調節線程數量，所以比較適合執行大量的短期的小任務。
public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}? ? ?
? ? ?9.6、newScheduledThreadPool?
? ? ? ? ? ??創建一個大小無限的線程池，線程池中得線程能夠周期性地執行給定的任務，有兩種函數簽名：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)?
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);}
?
?
總結：
1、本篇文章的demo例子已上傳至github:?https://github.com/zyj1609wz/AsyncTaskDemo
2、本人微信公眾賬號：zhaoyanjun125 ?， ? 歡迎關注
? ??
?
總結
以上是生活随笔為你收集整理的Android AsyncTask 深度理解、简单封装、任务队列分析、自定义线程池的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： EditText 显示明文和密码
- 下一篇： Android 自定义线程池的实战