Java-ThreadPool執行緒池總結

Tttori發表於2021-08-19
Javathread執行緒

ThreadPool


執行緒池的優勢

執行緒池做的工作主要是控制執行的執行緒數量，處理過程中將任務放入佇列，然後線上程建立後啟動這些任務，如果執行緒數量超過了最大數量，超出的執行緒排隊等候，等待其他執行緒執行完畢，再從佇列中取出任務來執行


執行緒池的特點

執行緒複用、控制最大併發數、管理執行緒

  • 降低資源消耗。重複利用已建立的執行緒，降低建立和銷燬執行緒的開銷

  • 提高響應速度。當任務到達時，任務可以不需要等待執行緒建立就能立刻執行

  • 提高執行緒的可管理性。使用執行緒池可以對執行緒進行統一的分配、調優和監控


1 執行緒池的方法


  • 執行長期任務效能好，建立一個執行緒池，一池有N個固定的執行緒，可以控制執行緒最大併發數，有固定執行緒數的執行緒池
ExecutorService threadPool = Executors.newFixedThreadPool(N);
  • 單個任務執行，它只會使用單個工作執行緒，一池一執行緒
ExecutorService threadPool = Executors.newSingleThreadExecutor();
  • 執行短期非同步任務，可快取執行緒池，執行緒池根據需要建立新執行緒，但在先前構造的執行緒可以複用，也可靈活回收空閒的執行緒，可擴容的池
ExecutorService threadPool = Executors.newCachedThreadPool();
  • 週期性執行緒池；支援定時及週期性任務執行
ExecutorService threadPool = Executors.newScheduledThreadPool();

(1) newFixedThreadPool

可以控制執行緒最大併發數的執行緒池：

public class FixedThreadPool {

    private static AtomicInteger num = new AtomicInteger(0);

    private static ExecutorService executorService = Executors.newFixedThreadPool(2);

    public static void main(String[] args) {
        countSum c= new countSum();
        //將coutSum作為Task，submit至執行緒池
        for (int i = 0; i < 2; i++) {
            executorService.submit(c);
        }
        //Task執行完成後關閉
        executorService.shutdown();
    }

    static class countSum implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 500; i++) {
                try{
                    System.out.println("Thread - "+Thread.currentThread().getName()+" count= "+ num.getAndIncrement());
                    Thread.sleep(100);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

結果：


(2) newSingleThreadExecutor

只會使用唯一的工作執行緒執行任務的執行緒池：

public class SingleThreadExecutor {

    private static AtomicInteger num = new AtomicInteger(0);

    private static ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        //將coutSum作為Task，submit至執行緒池
        for (int i = 0; i < 2; i++) {
            executorService.submit(new countSum());
        }
        //Task執行完成後關閉
        executorService.shutdown();
    }

    static class countSum implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 500; i++) {
                try{
                    System.out.println("Thread - "+Thread.currentThread().getName()+" count= "+ num.getAndIncrement());
                    Thread.sleep(100);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

結果：


(3) newScheduledThreadPool

傳參值為corePoolSize大小，支援定時及週期性任務執行

延期執行示例：呼叫schedule方法，三個引數：Task，Delay，TimeUnit

public class ScheduledThreadPool {
    // corePoolSize = 2
    private static ScheduledExecutorService service = Executors.newScheduledThreadPool(2);

    public static void main(String[] args) {
        System.out.println("Thread - "+Thread.currentThread().getName()+" BEGIN "+ new Date());

        service.schedule(new print(),5, TimeUnit.SECONDS);

        service.shutdown();
    }

    static class print implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try{
                    System.out.println("Thread - "+Thread.currentThread().getName()+" Delay 5 second and sleep 2 second "+ new Date());
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

結果：


定時執行示例：呼叫scheduleAtFixedRate方法，四個引數：Task，initialDelay，Period，TimeUnit

public class ScheduledThreadPool {
    // corePoolSize = 1
    private static ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

    public static void main(String[] args) {

        System.out.println("Thread - "+Thread.currentThread().getName()+" BEGIN "+ new Date());

        service.scheduleAtFixedRate(new print(),5,3,TimeUnit.SECONDS);
    }

    static class print implements Runnable{
        @Override
        public void run() {
            System.out.println("Thread - "+Thread.currentThread().getName()+" Delay 5 second and period 3 second "+ new Date());
        }
    }
}

結果：


(4) newCachedThreadPool

可快取執行緒池，如果執行緒池長度超過處理需要，回收空閒執行緒，若無可回收，則新建執行緒。即若前一個任務已完成，則會接著複用該執行緒：

public class CachedThreadPool {

    private static AtomicInteger num = new AtomicInteger(0);

    private static ExecutorService service = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        countSum c = new countSum();
        for (int i = 0; i < 3; i++) {
            try {
                service.submit(c);
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        service.shutdown();
    }

    static class countSum implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread - "+Thread.currentThread().getName()+" countSum= "+num.getAndIncrement());
            }
        }
    }
}

結果：Thread.sleep(1000)即sleep一秒，上個任務完成可繼續複用該執行緒，不需要建立新的執行緒

若將Tread.sleep(1000)註釋掉，你會發現有3個執行緒在跑

若感興趣可以去了解一下它們的底層原始碼，對於CachedThreadPool而言，可新建執行緒最大數量為INTEGER.MAXIMUM


2 執行緒池底層原理


以newFixedThreadPool為例

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>());
}


public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);
    }

執行緒池七大引數

  • corePoolSize：執行緒池中的常駐核心執行緒數

  • maximumPoolSize：執行緒池中能夠容納同時執行的最大執行緒數，必須大於1

  • keepAliveTime：多餘的空閒執行緒的存活時間；當前池中執行緒數量超過corePoolSize時，當空閒時間達到keepAliveTime時，多餘執行緒會被銷燬

  • unit：keepAliveTime的單位

  • workQueue：任務佇列，被提交但尚未執行的任務

  • threadFactory：表示生成執行緒池中工作執行緒的執行緒工廠，用於建立執行緒，一般預設

  • handler：拒絕策略，表示當佇列滿了，並且工作執行緒大於等於執行緒池的最大執行緒數時如何來拒絕請求執行的runnable的策略

image


執行緒池四大流程

1）建立執行緒池後，開始等待請求

2）當呼叫execute()方法新增一個請求任務時，執行緒池會做以下判斷：

  • 如果正在執行的執行緒數量小於corePoolSize，馬上建立執行緒執行任務

  • 如果正在執行的執行緒數量大於等於corePoolSize，將該任務放入等待佇列

  • 如果等待佇列已滿，但正在執行執行緒數量小於max，建立非核心執行緒執行任務

  • 如果佇列滿了且正在執行的執行緒數量大於max，執行緒池會啟動飽和拒絕策略

3）當一個執行緒完成任務時，會從等待佇列中取下一個任務來執行

4）當空閒執行緒超過keepAliveTime定義時間，會判斷：

  • 如果當前執行執行緒大於corePoolSize，該執行緒銷燬

  • 所有執行緒執行完任務後，執行緒個數恢復到corePoolSize大小


3 執行緒池策略及分析

Note：阿里巴巴JAVA開發手冊：執行緒池不允許使用Executors去建立執行緒池，而是通過使用ThreadPoolExecutor的方式自定義執行緒池，規避資源耗盡的風險

Executors返回的執行緒池物件的弊端：

1）FixedThreadPool和SingleThreadPool：

​ 允許請求佇列長度為Integer.MAX_VALUE，可能會堆積大量請求導致OOM

2）CachedThreadPool和ScheduledThreadPool：

​ 允許建立執行緒數量為Integer.MAX_VALUE，可能會建立大量的執行緒導致OOM


拒絕策略

1）AbortPolicy

​ 直接丟擲RejectedExecutionException異常阻止系統正常執行

2）CallerRunsPolicy

​ "呼叫者執行"的調節機制，該策略既不會拋棄任務，也不會丟擲異常，而是將某些任務回退到呼叫者，從而降低新任務的流量

3）DiscardPolicy

​ 該策略拋棄無法處理的任務，不予任何處理也不丟擲異常。如果允許任務丟失，這是最好的一種策略

4）DiscardOldestPolicy

​ 拋棄佇列中等待最久的任務，然後把當前任務加入佇列中嘗試再次提交當前任務


如何設定maximumPoolSize大小

Runtime.getRuntime().availableProcessors()方法獲取核數

CPU密集型

​ maximumPoolSize設為核數+1

IO密集型

​ maximumPoolSize設為核數/阻塞係數

相關文章