1. 程式人生 > >Java提供的幾種執行緒池

Java提供的幾種執行緒池

執行緒池,顧名思義,放執行緒的池子嘛,這個池子可以存放多少執行緒取決於你自己採用什麼樣的執行緒池,你的硬體資源,以及併發執行緒的數量。JDK提供了下面的四種執行緒池:

固定執行緒數的執行緒池

  1.  最簡單的

在Java中建立一個執行緒池,這很簡單,只需要兩行程式碼。

ExecutorService executor = Executor.newFixedTreadPool(6);//固定執行緒是6
//執行緒一般設定成processor核心數的倍數,因為我這臺機器是6核的,所以設成6。這也是充分利用硬體嘛

//執行執行緒任務
executor.execute(new Runnable(){
@Override
public void run(){
     //do nothing 
}
})
    
executor.shutdown();

Executor是Java併發包中提供的,用來創造不同型別的執行緒池。

Attention

但是在多人合作或者是一些部署上線的專案裡,是不允許去使用這種方法的,因為它是有效能隱患的。

Executors在建立執行緒池的時候,用的是new LinkedBlockingQueue(),它這個佇列本身是無邊界的,但是執行緒是固定數量的。這就意味著,在程式執行的過程中,最多會有N個執行緒在處於活動狀態。每次有新的任務來就會等待,直到有執行緒處於空閒狀態。所有的執行緒都會處於執行緒池裡裡面,直到shutdown()的執行。

它的問題就在於來者不拒,只要有任務來,你就進佇列等著。在入佇列和出佇列用的並不是同一個lock,在多processor的機器上,是可以做到真正意義上的並行的。拿經典的生產者和消費者來舉例子,在同一個時間點,有的在消費,有的在生產。

這種執行緒池不會銷燬執行緒,不會拒絕任務,固定執行緒數。所以如果不停的加入任務,會導致很糟糕的記憶體佔用,老年代可能會被佔滿。

  1.  稍複雜的(可以延時執行,也可以執行帶返回值的任務)
public static void main(String[] args) throws InterruptedException, ExecutionException {
        TestThread testThread = new TestThread();
        System.out.println(testThread.processors);

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(6);
        FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return Thread.currentThread().getName();
            }
        });
        scheduledExecutorService.submit(futureTask);

        //獲取返回值
        String result = futureTask.get();
        System.out.println("result :"+result);

        //執行延時任務
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+": bomb!");
            }
        },3L,TimeUnit.SECONDS);
    }

Output:

result :pool-1-thread-1
pool-1-thread-1: bomb!

快取的執行緒池

核心池大小為0,執行緒池最大執行緒數目為最大整型,這意味著所有的任務一提交就會wait。當執行緒池中的執行緒有60s沒有執行任務就會被Kill,阻塞佇列為SynchronousQueue。SynchronousQueue的take操作需要put操作等待,put操作需要take操作等待,否則會阻塞(執行緒池的阻塞佇列不能儲存,所以當目前執行緒處理忙碌狀態時,會開闢新的執行緒來處理請求**),執行緒進入wait set。

總結一下這是一個可以無限擴大的執行緒池;適合處理執行時間比較小的任務;執行緒空閒時間超過60s就會被Kill,所以長時間處於空閒狀態的時候,這種執行緒池幾乎不佔用資源,因為它壓根沒有執行緒在裡面;阻塞佇列沒有儲存空間,只要請求到來,就必須找到一條空閒執行緒去處理這個請求,找不到則線上程池新開闢一條執行緒。

如果主執行緒提交任務的速度遠遠大於CachedThreadPool的處理速度,則CachedThreadPool會不斷地建立新執行緒來執行任務,這樣有可能會導致系統耗盡CPU和記憶體資源,所以在使用該執行緒池時,要注意控制併發的任務數。如果是一個不斷增長的任務需求,很容易就會到效能瓶頸,它會不停的建立新的執行緒。

 ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        cachedThreadPool.shutdown();

Output:

pool-1-thread-2
pool-1-thread-6
pool-1-thread-1
pool-1-thread-7
pool-1-thread-8
pool-1-thread-3
pool-1-thread-5
pool-1-thread-9
pool-1-thread-4
pool-1-thread-10

單個執行緒的執行緒池

SingleThreadExecutor 是使用單個worker執行緒的Executor。只有一種情況會有新的執行緒加入執行緒池,那就是原有的執行緒執行時有丟擲異常,這時就會有建立的新的執行緒來替代它的工作。

拿生產者消費者模型來說的話,這就是一個單一消費者的模型。

(ps.一般可以用來做一些日誌記錄

 public static void main(String[] args) {
        // 永遠是一條執行緒
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int j = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + j);
                }
            });
        }
        singleThreadPool.shutdown();
        
    }

Output:

pool-1-thread-1:0
pool-1-thread-1:1
pool-1-thread-1:2
pool-1-thread-1:3
pool-1-thread-1:4
pool-1-thread-1:5
pool-1-thread-1:6
pool-1-thread-1:7
pool-1-thread-1:8
pool-1-thread-1:9