coding++：java 線程池概述

前言：

1）：建立一個可緩存線程池

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

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

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

5）：緩沖隊列BlockingQueue 和自定義線程池 ThreadPoolExecutor

線程池簡介:

1、線程池的概念：

線程池就是首先建立一些線程，它們的集合稱為線程池。

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

等待執行下一個任務。

2、線程池的工作機制：

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

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

3、使用線程池的原因：

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

4、使用new Thread()建立線程的弊端

每次通過new Thread()建立對象性能不佳。

線程缺乏統一管理，可能無限制建立線程，互相之間競争，及可能占用過多系統資源導緻當機或oom。

缺乏更多功能，如定時執行、定期執行、線程中斷。

5、使用線程池的好處

重用存在的線程，減少對象建立、消亡的開銷，提升性能。

可有效控制最大并發線程數，提高系統資源的使用率，同時避免過多資源競争，避免堵塞。

提供定時執行、定期執行、單線程、并發數控制等功能。

Java通過Executors提供四種線程池，分别為：

newCachedThreadPool 建立一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則建立線程。

newFixedThreadPool 建立一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。

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

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

示例代碼（一）：建立一個可緩存線程池

Executors.newCacheThreadPool()：可緩存線程池，先檢視池中有沒有以前建立的線程，如果有，就直接使用。

如果沒有，就建一個新的線程加入池中，緩存型池子通常用于執行一些生存期很短的異步型任務

package com.study.test;

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)：建立一個可重用固定個數的線程池，以共享的無界隊列方式來運作這些線程。

示例代碼：

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-2正在被執行

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

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

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

示例代碼（三）：Executors.newScheduledThreadPool(int n)：建立一個定長線程池，支援定時及周期性任務執行

延遲執行示例代碼：

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

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秒執行

定期執行示例代碼：

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, 優先級)執行。

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

緩沖隊列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，對其的操作必須是放和取交替完成。

自定義線程池（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;

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 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();// 3個任務在分别在3個線程上執行
    tpe.execute(t1);
    tpe.execute(t2);
    tpe.execute(t3);// 關閉自定義線程池
    tpe.shutdown();
}

更多：ThreadPoolExecutor 詳解點選跳轉

原文位址

https://www.cnblogs.com/codingmode/p/12705354.html

coding++：java 線程池概述

繼續閱讀

關于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