java并發原理實戰(13)--線程池和Executors

線程池

一. 線程池簡介

1. 線程池的概念：
2. 線程池的工作機制
3. 使用線程池的原因：

二. 5種常見的線程池詳解

1. 線程池的傳回值ExecutorService簡介：
2. 具體的5種常用的線程池實作如下：（傳回值都是ExecutorService）

①Executors.newCacheThreadPool()：
② Executors.newFixedThreadPool(int n)：
③Executors.newScheduledThreadPool(int n)
④ Executors.newSingleThreadExecutor()：
⑤ Executors.newWorkStealingPool()：

三. 緩沖隊列BlockingQueue和自定義線程池ThreadPoolExecutor

1.緩沖隊列BlockingQueue簡介：
2.常用的幾種BlockingQueue：
3.自定義線程池（ThreadPoolExecutor和BlockingQueue連用）：

一. 線程池簡介

1. 線程池的概念：

線程池就是首先建立一些線程，它們的集合稱為線程池。使用線程池可以很好地提高性能，線程池在系統啟動時即建立大量空閑的線程，程式将一個任務傳給線程池，線程池就會啟動一條線程來執行這個任務，執行結束以後，該線程并不會死亡，而是再次傳回線程池中成為空閑狀态，等待執行下一個任務。

2. 線程池的工作機制

線上程池的程式設計模式下，任務是送出給整個線程池，而不是直接送出給某個線程，線程池在拿到任務後，就在内部尋找是否有空閑的線程，如果有，則将任務交給某個空閑的線程。

一個線程同時隻能執行一個任務，但可以同時向一個線程池送出多個任務。

3. 使用線程池的原因：

多線程運作時間，系統不斷的啟動和關閉新線程，成本非常高，會過渡消耗系統資源，以及過渡切換線程的危險，進而可能導緻系統資源的崩潰。這時，線程池就是最好的選擇了。

二. 5種常見的線程池詳解

1. 線程池的傳回值ExecutorService簡介：

ExecutorService是Java提供的用于管理線程池的接口。該接口的兩個作用：控制線程數量和重用線程

2. 具體的5種常用的線程池實作如下：（傳回值都是ExecutorService）

①Executors.newCacheThreadPool()：

可緩存線程池，先檢視池中有沒有以前建立的線程，如果有，就直接使用。如果沒有，就建一個新的線程加入池中，緩存型池子通常用于執行一些生存期很短的異步型任務

示例代碼：

import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //建立一個可緩存線程池
         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
         for (int i = 0; i < 10; i++) {
             try {
                 //sleep可明顯看到使用的是線程池裡面以前的線程，沒有建立新的線程
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             cachedThreadPool.execute(new Runnable() {
                 public void run() {
                     //列印正在執行的緩存線程資訊
                     System.out.println(Thread.currentThread().getName()+"正在被執行");
                 }
             });
         }
     }
 }

輸出結果：

pool-1-thread-1正在被執行

線程池為無限大，當執行目前任務時上一個任務已經完成，會複用執行上一個任務的線程，而不用每次建立線程

② Executors.newFixedThreadPool(int n)：

建立一個可重用固定個數的線程池，以共享的無界隊列方式來運作這些線程。

示例代碼：

import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //建立一個可重用固定個數的線程池
         ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
         for (int i = 0; i < 10; i++) {
             fixedThreadPool.execute(new Runnable() {
                 public void run() {
                     try {
                         //列印正在執行的緩存線程資訊
                         System.out.println(Thread.currentThread().getName()+"正在被執行");
                         Thread.sleep(2000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             });
         }
     }
 }

輸出結果：

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

pool-1-thread-1正在被執行

pool-1-thread-2正在被執行

pool-1-thread-3正在被執行

pool-1-thread-1正在被執行

因為線程池大小為3，每個任務輸出列印結果後sleep 2秒，是以每兩秒列印3個結果。

定長線程池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()

③Executors.newScheduledThreadPool(int n)

建立一個定長線程池，支援定時及周期性任務執行

延遲執行示例代碼：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //建立一個定長線程池，支援定時及周期性任務執行——延遲執行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延遲1秒執行
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("延遲1秒執行");
            }
        }, 1, TimeUnit.SECONDS);
    }
}

輸出結果：延遲1秒執行

定期執行示例代碼：

import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //建立一個定長線程池，支援定時及周期性任務執行——定期執行
         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
         //延遲1秒後每3秒執行一次
         scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
             public void run() {
                 System.out.println("延遲1秒後每3秒執行一次");
             }
         }, 1, 3, TimeUnit.SECONDS);
     }
 }

輸出結果：

延遲1秒後每3秒執行一次

…

④ Executors.newSingleThreadExecutor()：

建立一個單線程化的線程池，它隻會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

示例代碼：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        //建立一個單線程化的線程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        //結果依次輸出，相當于順序執行各個任務
                        System.out.println(Thread.currentThread().getName()+"正在被執行,列印的值是:"+index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

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

⑤ Executors.newWorkStealingPool()：

jdk1.8新增的：每個線程都有要處理的隊列中的任務，如果其中的線程完成自己隊列中的任務，

那麼它可以去其他線程中擷取其他線程的任務去執行

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
/**
 * 線程池
 *    1.固定個數的線程池
 *    2.緩存線程池，開始線程數0
 *         如果需要線程，目前線程池沒有，那麼建立線程池
 *         如果需要線程，線程池中有沒有使用的線程，那麼使用已經存在的線程
 *         如果線程池中線程超過60秒(預設)沒有使用，那麼該線程停止
 *    3.隻有1個線程的線程池
 *         保證線程執行的先後順序
 *    4.ScheduledPool
 *          和DelayedQueue類似,定時執行
 *    5.WorkStealingPool(任務竊取，都是守護線程)
 *          每個線程都有要處理的隊列中的任務，如果其中的線程完成自己隊列中的任務，
 *          那麼它可以去其他線程中擷取其他線程的任務去執行
 */
public class Demo {
    /*
        4
        1000:ForkJoinPool-1-worker-1
        1000:ForkJoinPool-1-worker-0
        2000:ForkJoinPool-1-worker-2
        3000:ForkJoinPool-1-worker-3
        2000:ForkJoinPool-1-worker-1
        public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }
     */
    public static void main(String[] args) throws IOException {
        // 根據cpu是幾核來開啟幾個線程
        ExecutorService service = Executors.newWorkStealingPool();
        // 檢視目前計算機是幾核
        System.out.println(Runtime.getRuntime().availableProcessors());
        service.execute(new R(1000));
        service.execute(new R(2000));
        service.execute(new R(3000));
        service.execute(new R(1000));
        service.execute(new R(2000));
 
        // WorkStealing是精靈線程(守護線程、背景線程)，主線程不阻塞，看不到輸出。
        // 虛拟機不停止，守護線程不停止
        System.in.read();
    }
 
    static class R implements Runnable {
        int time;
 
        public R(int time) {
            this.time = time;
        }
 
        @Override
        public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(time + ":" + Thread.currentThread().getName());
        }
    }
}

三. 緩沖隊列BlockingQueue和自定義線程池ThreadPoolExecutor

1.緩沖隊列BlockingQueue簡介：

BlockingQueue是雙緩沖隊列。BlockingQueue内部使用兩條隊列，允許兩個線程同時向隊列一個存儲，一個取出操作。在保證并發安全的同時，提高了隊列的存取效率。

2.常用的幾種BlockingQueue：

ArrayBlockingQueue（int i）:規定大小的BlockingQueue，其構造必須指定大小。其所含的對象是FIFO順序排序的。
LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其構造時指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE來決定。其所含的對象是FIFO順序排序的。
PriorityBlockingQueue（）或者（int i）:類似于LinkedBlockingQueue，但是其所含對象的排序不是FIFO，而是依據對象的自然順序或者構造函數的Comparator決定。
SynchronizedQueue（）:特殊的BlockingQueue，對其的操作必須是放和取交替完成。

3.自定義線程池（ThreadPoolExecutor和BlockingQueue連用）：

自定義線程池，可以用ThreadPoolExecutor類建立，它有多個構造方法來建立線程池。

常見的構造函數：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

示例代碼：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class TempThread implements Runnable {

    @Override
    public void run() {
        // 列印正在執行的緩存線程資訊
        System.out.println(Thread.currentThread().getName() + "正在被執行");
        try {
            // sleep一秒保證3個任務在分别在3個線程上執行
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        // 建立數組型緩沖等待隊列
        BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
        // ThreadPoolExecutor:建立自定義線程池，池中儲存的線程數為3，允許最大的線程數為6
        ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);

        // 建立3個任務
        Runnable t1 = new TempThread();
        Runnable t2 = new TempThread();
        Runnable t3 = new TempThread();
        // Runnable t4 = new TempThread();
        // Runnable t5 = new TempThread();
        // Runnable t6 = new TempThread();

        // 3個任務在分别在3個線程上執行
        tpe.execute(t1);
        tpe.execute(t2);
        tpe.execute(t3);
        // tpe.execute(t4);
        // tpe.execute(t5);
        // tpe.execute(t6);

        // 關閉自定義線程池
        tpe.shutdown();
    }
}

輸出結果：

java并發原理實戰(13)--線程池和Executors

線程池

一. 線程池簡介

1. 線程池的概念：

2. 線程池的工作機制

3. 使用線程池的原因：

二. 5種常見的線程池詳解

1. 線程池的傳回值ExecutorService簡介：

2. 具體的5種常用的線程池實作如下：（傳回值都是ExecutorService）

①Executors.newCacheThreadPool()：

② Executors.newFixedThreadPool(int n)：

③Executors.newScheduledThreadPool(int n)

④ Executors.newSingleThreadExecutor()：

⑤ Executors.newWorkStealingPool()：

三. 緩沖隊列BlockingQueue和自定義線程池ThreadPoolExecutor

1.緩沖隊列BlockingQueue簡介：

2.常用的幾種BlockingQueue：

3.自定義線程池（ThreadPoolExecutor和BlockingQueue連用）：

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method