ThreadPool：線程池

　　1、定義

　　緩存一定線程數量的區域。

　　2、作用

　　復用、管理線程，避免新建線程/銷毀線程消耗CPU資源。

　　3、核心參數

　　參數　　作用

　　corePoolSize(核心線程數)　　核心線程會一直存活

　　maximumPoolSize(最大線程數)　　活動線程達到最大線程數，后續新任務會阻塞

　　keepAliveTime(閑置線程超時時長)　　非核心線程閑置超過該時長將被回收(設置作用于核心線程threadPoolExecutor.allowCoreThreadTimeOut(true))

　　unit(keepAliveTime 單位)　　如：TimeUnit.MILLISECONDS, TimeUnit.SECONDS

　　workQueue(任務隊列)　　存放 execute() 提交的 Runnable 對象

　　threadFactory(線程工廠)　　為線程池創建線程，Thread newThread(Runnable r)

　　4、工作流程

　　5、常用線程池

　　類型　　線程類型　　線程數量　　特點　　場景

　　定長線程池(FixedThreadPool)　　核心線程　　固定　　1、核心線程空閑不會回收。2、所有線程處于活動狀態，新的任務將處于等待狀態，直到有線程空閑。3、任務隊列無大小限制。4、堆積的任務可能占用大內存　　控制線程最大并發數

　　定時線程池(ScheduledThreadPool)　　核心、非核心線程　　核心:固定，非核心:無限制　　1、非核心線程閑置時會被回收。2、非核心線程無限制可能創建非常多線程。　　執行定時/ 周期性任務

　　可緩存線程池(CachedThreadPool)　　非核心　　無限制　　1、優先使用閑置線程處理任務。2、線程大小無限制。3、60 秒 回收閑置線程。4、非核心線程無限制可能創建非常多線程。　　執行數量多、耗時少的任務

　　單線程線程池(SingleThreadExecutor)　　核心線程　　1個　　1、任務順序執行。2、不需要處理線程同步。3、堆積的任務可能占用大內存　　單線程

　　6、具體使用

　　public class ExecutorDemo {

　　public static void main(String[] args) {

　　createThreadPoolExecutor();

　　createFixedThreadPool();

　　createScheduledThreadPool();

　　createCachedThreadPool();

　　createSingleThreadExecutor();

　　}

　　private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

　　private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));

　　private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;

　　private static final int KEEP_ALIVE_SECONDS = 30;

　　private static final BlockingQueue sPoolWorkQueue =

　　new LinkedBlockingQueue(128);

　　private static final ThreadFactory sThreadFactory = new ThreadFactory() {

　　private final AtomicInteger mCount = new AtomicInteger(1);

　　@Override

　　public Thread newThread(Runnable r) {

　　return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());

　　}

　　};

　　public static void createThreadPoolExecutor() {

　　// 1.創建自定義線程池

　　ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(

　　CORE_POOL_SIZE,

　　MAXIMUM_POOL_SIZE,

　　KEEP_ALIVE_SECONDS,

　　TimeUnit.SECONDS,

　　sPoolWorkQueue,

　　sThreadFactory);

　　threadPoolExecutor.allowCoreThreadTimeOut(true);

　　// 2.創建任務

　　Runnable task = new Runnable() {

　　@Override

　　public void run() {

　　System.out.println("自定義線程池-任務執行");

　　}

　　};

　　// 3.通過線程池執行任務

　　threadPoolExecutor.execute(task);

　　// 4.關閉線程池

　　threadPoolExecutor.shutdown();

　　}

　　public static void createFixedThreadPool() {

　　// 1.創建定長線程池

　　// public static ExecutorService newFixedThreadPool(int var0) {

　　// return new ThreadPoolExecutor(var0, var0, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());

　　// }

　　ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

　　// 2.創建任務

　　Runnable task = new Runnable() {

　　@Override

　　public void run() {

　　System.out.println("定長線程池-任務執行");

　　}

　　};

　　// 3.通過線程池執行任務

　　fixedThreadPool.execute(task);

　　// 4.關閉線程池

　　fixedThreadPool.shutdown();

　　}

　　public static void createScheduledThreadPool() {

　　// 1.創建定時線程池

　　// public ScheduledThreadPoolExecutor(int var1) {

　　// super(var1, 2147483647, 0L, TimeUnit.NANOSECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue());

　　// }　無錫婦科醫院排行 http://www.0510bhyy.com/

　　ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

　　// 2.創建任務

　　Runnable task = new Runnable() {

　　@Override

　　public void run() {

　　System.out.println("定時線程池-任務執行");

　　}

　　};

　　// 3.通過線程池執行任務,execute 立即執行，schedule 延遲1s執行,scheduleAtFixedRate 延遲1s執行之后每隔2秒執行

　　// scheduledThreadPool.execute(task);

　　scheduledThreadPool.schedule(task, 1000L, TimeUnit.MILLISECONDS);

　　// scheduledThreadPool.scheduleAtFixedRate(task,1000L,2000L, TimeUnit.MILLISECONDS);

　　// 4.關閉線程池

　　scheduledThreadPool.shutdown();

　　}

　　public static void createCachedThreadPool() {

　　// 1.創建可緩存線程池

　　// public static ExecutorService newCachedThreadPool() {

　　// return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());

　　// }

　　ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

　　// 2.創建任務

　　Runnable task = new Runnable() {

　　@Override

　　public void run() {

　　System.out.println("可緩存線程池-任務執行");

　　}

　　};

　　// 3.通過線程池執行任務

　　cachedThreadPool.execute(task);

　　// 4.關閉線程池

　　cachedThreadPool.shutdown();

　　}

　　public static void createSingleThreadExecutor() {

　　// 1.創建單線程線程池

　　// public static ExecutorService newSingleThreadExecutor() {

　　// return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));

　　// }

　　ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

　　// 2.創建任務

　　Runnable task = new Runnable() {

　　@Override

　　public void run() {

　　System.out.println("單線程線程池-任務執行");

　　}

　　};

　　// 3.通過線程池執行任務

　　singleThreadExecutor.execute(task);

　　// 4.關閉線程池

　　singleThreadExecutor.shutdown();

　　}

　　}