分類: 發燒車訊

目錄

無論是 NoSQL，還是大數據領域，HBase 都是非常”炙熱”的一門數據庫。
本文將對 HBase 做一些基礎性的介紹，旨在入門。

一、簡介

HBase 是一個開源的、面向列的非關係型分佈式數據庫，目前是Hadoop體系中非常關鍵的一部分。
在最初，HBase是基於谷歌的 BigTable 原型實現的，許多技術來自於Fay Chang在2006年所撰寫的Google論文”BigTable”。與 BigTable基於Google文件系統（File System）一樣，HBase則是基於HDFS(Hadoop的分佈式文件系統)之上而開發的。

HBase 採用 Java 語言實現，在其內部實現了BigTable論文提到的一些壓縮算法、內存操作和布隆過濾器等，這些能力使得HBase 在海量數據存儲、高性能讀寫場景中得到了大量應用，如 Facebook 在 2010年11 月開始便一直選用 HBase來作為消息平台的存儲層技術。
HBase 以 Apache License Version 2.0開源，這是一種對商業應用友好的協議，同時該項目當前也是Apache軟件基金會的頂級項目之一。

有什麼特性

• 基於列式存儲模型，對於數據實現了高度壓縮，節省存儲成本
• 採用 LSM 機制而不是B(+)樹，這使得HBase非常適合海量數據實時寫入的場景
• 高可靠，一個數據會包含多個副本(默認是3副本)，這得益於HDFS的複製能力，由RegionServer提供自動故障轉移的功能
• 高擴展，支持分片擴展能力(基於Region)，可實現自動、數據均衡
• 強一致性讀寫，數據的讀寫都針對主Region上進行，屬於CP型的系統
• 易操作，HBase提供了Java API、RestAPI/Thrift API等接口
• 查詢優化，採用Block Cache 和 布隆過濾器來支持海量數據的快速查找

與RDBMS的區別

對於傳統 RDBMS 來說，支持 ACID 事務是數據庫的基本能力，而 HBase 則使用行級鎖來保證寫操作的原子性，但是不支持多行寫操作的事務性，這主要是從靈活性和擴展性上做出的權衡。

ACID 要素包含 原子性（Atomicity）、一致性（Consistency）、隔離性（Isolation）以及持久性（Durability）

總體來說， HBase 與傳統關係數據庫的區別，如下錶所示：

二、數據模型

下面，我們以關係型數據庫的一個數據表來演示 HBase 的不同之處。 先來看下面這張表：

這裏記錄的是一些家庭設備上報的狀態數據(DeviceState)，其中包括設備名、狀態、時間戳這些字段。

在 HBase 中，數據是按照列族(Column Family，簡稱CF)來存儲的，也就是說對於不同的列會被分開存儲到不同的文件。
那麼對於上面的狀態數據表來說，在HBase中會被存儲為兩份：

列族1. 設備名

列族2. 狀態

這裏Row-key是唯一定位數據行的ID字段，而Row-key 加上 CF、Column-Key，再加上一個時間戳才可以定位到一個單元格數據。
其中時間戳用來表示數據行的版本， 在HBase中默認會有 3 個時間戳的版本數據，這意味着對同一條數據(同一個Rowkey關聯的數據)進行寫入時，最多可以保存3個版本。

在查詢某一行的數據時，HBase需要同時從兩個列族(文件)中進行查找，最終將結果合併后返回給客戶端。 由此可見如果列族太多，則會影響讀取的性能，在設計時就需要做一些權衡。

由此可見，HBase的使用方式與關係型數據庫是大不相同的，在使用 HBase 時需要拋棄許多關係型數據庫的思維及做法，比如強類型、二級索引、表連接、觸發器等等。

然而 HBase 的靈活性及高度可伸縮性卻是傳統 RDBMS 無法比擬的。

三、安裝HBase

單機環境安裝

1. 準備JDK環境

確保環境上JDK已經裝好，可執行java -version確認：

host:/home/hbase # java -version
openjdk version "1.8.0_201"
OpenJDK Runtime Environment (build 1.8.0_201-Huawei_JDK_V100R001C00SPC060B003-b10)
OpenJDK 64-Bit Server VM (build 25.201-b10, mixed mode)

1. 下載軟件

官網的下載地址頁面：

選擇合適的版本，比如1.4.10。 下載后解壓：

wget http://archive.apache.org/dist/hbase/2.1.5/hbase-2.1.5-bin.tar.gz
tar -xzvf hbase-2.1.5-bin.tar.gz
mkdir -p /opt/local
mv hbase-2.1.5 /opt/local/hbase

配置HBase執行命令路徑：

export HBASE_HOME=/opt/local/hbase
export PATH=$PATH:$HBASE_HOME/bin

1. 配置軟件

vim conf/hbase-env.sh

#JDK安裝目錄
export JAVA_HOME=/usr/local/jre1.8.0_201
#配置hbase自己管理zookeeper
export HBASE_MANAGES_ZK=true

vim conf/hbase-site.xml

<configuration>

  <!-- zookeeper端口  -->
  <property>
      <name>hbase.zookeeper.property.clientPort</name>
      <value>2182</value>                                                                                                                                           
  </property>

  <!--  HBase 數據存儲目錄 -->
  <property>
    <name>hbase.rootdir</name>
    <value>file:///opt/local/hbase/data</value>
  </property>

  <!-- 用於指定 ZooKeeper 數據存儲目錄 -->
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/opt/local/hbase/data/zookeeper</value>
  </property>

  <!-- 用於指定臨時數據存儲目錄 -->
  <property>
    <name>hbase.tmp.dir</name>
    <value>/opt/local/hbase/temp/hbase-${user.name}</value>
  </property>
</configuration>

其中 hbase.rootdir 和 hbase.zookeeper.property.dataDir 都用來指定數據存放的目錄，默認情況下hbase會使用/tmp目錄，這顯然是不合適的。
配置了這兩個路徑之後，hbase會自動創建相應的目錄。

關於更多的參數設定可

1. 啟動軟件

start-hbase.sh

此時查看 logs/hbase-root-master-host-xxx.log，如下：

2019-07-11 07:37:23,654 INFO  [localhost:33539.activeMasterManager] hbase.MetaMigrationConvertingToPB: hbase:meta doesn't have any entries to update.
2019-07-11 07:37:23,654 INFO  [localhost:33539.activeMasterManager] hbase.MetaMigrationConvertingToPB: META already up-to date with PB serialization
2019-07-11 07:37:23,664 INFO  [localhost:33539.activeMasterManager] master.AssignmentManager: Clean cluster startup. Assigning user regions
2019-07-11 07:37:23,665 INFO  [localhost:33539.activeMasterManager] master.AssignmentManager: Joined the cluster in 11ms, failover=false
2019-07-11 07:37:23,672 INFO  [localhost:33539.activeMasterManager] master.TableNamespaceManager: Namespace table not found. Creating...

檢查進程情況，發現進程已經啟動

ps -ef |grep hadoop
root     11049 11032  2 07:37 pts/1    00:00:20 /usr/local/jre1.8.0_201/bin/java -Dproc_master -XX:OnOutOfMemoryError=kill -9 %p -XX:+UseConcMarkSweepGC -XX:PermSize=128m -XX:MaxPermSize=128m -XX:ReservedCodeCacheSize=256m -Dhbase.log.dir=/opt/local/hbase/logs -Dhbase.log.file=hbase-root-master-host-192-168-138-148.log -Dhbase.home.dir=/opt/local/hbase -Dhbase.id.str=root -Dhbase.root.logger=INFO,RFA -Dhbase.security.logger=INFO,RFAS org.apache.hadoop.hbase.master.HMaster start
root     18907 30747  0 07:50 pts/1    00:00:00 grep --color=auto hadoop

通過JPS(JDK自帶的檢查工具) 可以看到當前啟動的Java進程：

# jps
5701 Jps
4826 HMaster
1311 jar

查看 data目錄，發現生成了對應的文件：

host:/opt/local/hbase/data # ls -lh .
total 36K
drwx------. 4 root root 4.0K Jul 11 08:08 data
drwx------. 4 root root 4.0K Jul 11 08:08 hbase
-rw-r--r--. 1 root root   42 Jul 11 08:08 hbase.id
-rw-r--r--. 1 root root    7 Jul 11 08:08 hbase.version
drwx------. 2 root root 4.0K Jul 11 08:08 MasterProcWALs
drwx------. 2 root root 4.0K Jul 11 08:08 oldWALs
drwx------. 3 root root 4.0K Jul 11 08:08 .tmp
drwx------. 3 root root 4.0K Jul 11 08:08 WALs
drwx------. 3 root root 4.0K Jul 11 08:08 zookeeper

關於運行模式
HBase啟動時默認會使用單機模式，此時 Zookeeper和 HMaster/RegionServer 會運行在同一個JVM中。
以standalone模式啟動的HBase會包含一個HMaster、RegionServer、Zookeeper實例，此時 HBase 會直接使用本地文件系統而不是HDFS。

通過將 conf/hbase-site.xml中的 hbase.cluster.distributed 配置為true，就是集群模式了。
在這個模式下，你可以使用分佈式環境進行部署，或者是”偽分佈式”的多進程環境。

<configuration>
  <property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
  </property>
</configuration>

需要注意的是，如果以standalone啟動的話，HMaster、RegionServer端口都是隨機的，無法通過配置文件指定。

四、基本使用

打開HBase Shell

hbase shell

執行status命令

Version 2.1.5, r76ab087819fe82ccf6f531096e18ad1bed079651, Wed Jun  5 16:48:11 PDT 2019

hbase(main):001:0> status
1 active master, 0 backup masters, 1 servers, 0 dead, 2.0000 average load

這表示有一個Master在運行，一個RegionServer，每個RegionServer包含2個Region。

表操作

• 創建DeviceState表

hbase(main):002:0> create "DeviceState", "name:c1", "state:c2"

=> Hbase::Table - DeviceState

此時，已經創建了一個DeviceState表，包含name(設備名稱)、state(狀態)兩個列。

查看錶信息：

hbase(main):003:0> list
TABLE
DeviceState
1 row(s) in 0.0090 seconds

=> ["DeviceState"]

hbase(main):003:0> describe "DeviceState"
Table DeviceState is ENABLED
DeviceState
COLUMN FAMILIES DESCRIPTION
{NAME => 'name', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', COMPRESSIO
N => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE => '65536', REPLICATION_SCOPE => '0'}
{NAME => 'state', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', COMPRESSI
ON => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE => '65536', REPLICATION_SCOPE => '0'}
2 row(s) in 0.0870 seconds

• 寫入數據

通過下面的命令，向DeviceState寫入兩條記錄，由於有兩個列族，因此需要寫入四個單元格數據：

put "DeviceState", "row1", "name", "空調"
put "DeviceState", "row1", "state", "打開"
put "DeviceState", "row2", "name", "電視機"
put "DeviceState", "row2", "state", "關閉"

• 查詢數據

查詢某行、某列

hbase(main):012:0> get "DeviceState","row1"
COLUMN                                      CELL
 name:                                      timestamp=1562834473008, value=\xE7\x94\xB5\xE8\xA7\x86\xE6\x9C\xBA
 state:                                     timestamp=1562834474630, value=\xE5\x85\xB3\xE9\x97\xAD
1 row(s) in 0.0230 seconds

hbase(main):013:0> get "DeviceState","row1", "name"
COLUMN                                      CELL
 name:                                      timestamp=1562834473008, value=\xE7\x94\xB5\xE8\xA7\x86\xE6\x9C\xBA
1 row(s) in 0.0200 seconds

掃描表

hbase(main):026:0> scan "DeviceState"
ROW                                         COLUMN+CELL
 row1                                       column=name:, timestamp=1562834999374, value=\xE7\xA9\xBA\xE8\xB0\x83
 row1                                       column=state:, timestamp=1562834999421, value=\xE6\x89\x93\xE5\xBC\x80
 row2                                       column=name:, timestamp=1562834999452, value=\xE7\x94\xB5\xE8\xA7\x86\xE6\x9C\xBA
 row2                                       column=state:, timestamp=1562835001064, value=\xE5\x85\xB3\xE9\x97\xAD
2 row(s) in 0.0250 seconds

查詢數量

hbase(main):014:0> count "DeviceState"
2 row(s) in 0.0370 seconds

=> 1

• 清除數據

刪除某列、某行

delete "DeviceState", "row1", "name"
0 row(s) in 0.0080 seconds

hbase(main):003:0> deleteall "DeviceState", "row2"
0 row(s) in 0.1290 seconds

清空整個表數據

hbase(main):021:0> truncate "DeviceState"
Truncating 'DeviceState' table (it may take a while):
 - Disabling table...
 - Truncating table...
0 row(s) in 3.5060 seconds

刪除表(需要先disable)

hbase(main):006:0> disable "DeviceState"
0 row(s) in 2.2690 seconds

hbase(main):007:0> drop "DeviceState"
0 row(s) in 1.2880 seconds

五、FAQ

• 啟動時提示 ZK 端口監聽失敗：
  Could not start ZK at requested port of 2181. ZK was started at port: 2182. Aborting as clients (e.g. shell) will not be able to find this ZK quorum

原因
HBase需要啟動Zookeeper，而本地的2181端口已經被啟用(可能有其他Zookeeper實例)

解決辦法
conf/hbase-site.xml中修改hbase.zookeeper.property.clientPort的值，將其修改為2182，：

<configuration>
  <property>
      <name>hbase.zookeeper.property.clientPort</name>
      <value>2182</value>                                                                                                                                           
  </property>
</configuration>

• 啟動HBase Shell時提示java.lang.UnsatisfiedLinkError

原因
在執行hbase shell期間，JRuby會在“java.io.tmpdir”路徑下創建一個臨時文件，該路徑的默認值為“/tmp”。如果為“/tmp”目錄設置NOEXEC權限，然後hbase shell會啟動失敗並拋出“java.lang.UnsatisfiedLinkError”錯誤。

解決辦法

1. 取消/tmp的noexec權限(不推薦)
2. 設置java.io.tmpdir變量，指向可用的路徑，編輯conf/hbase-env.sh文件：

export HBASE_TMP_DIR=/opt/local/hbase/temp
export HBASE_OPTS="-XX:+UseConcMarkSweepGC -Djava.io.tmpdir=$HBASE_TMP_DIR"

參考文檔

HBase 官方權威指南

HBase 單機模式搭建

HBase 深入淺出
較詳細介紹了HBase的由來以及特性，文中提供了HBase集群、存儲機制的一些簡介，非常適合入門閱讀

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

有點笨，參考了好幾篇大佬們寫的文章才整理出來的筆記….

字面意思上解釋，線程池就是裝有線程的池，我們可以把要執行的多線程交給線程池來處理，和連接池的概念一樣，通過維護一定數量的線程池來達到多個線程的復用。

好處

多線程產生的問題

一般我們使用到多線程的編程的時候，需要通過new Thread(xxRunnable).start()創建並開啟線程，我們可以使用多線程來達到最優效率（如多線程下載）。

但是，線程不是越多就越好，線程過多，創建和銷毀就會消耗系統的資源，也不方便管理。

除此之外，多線程還會造成併發問題，線程併發數量過多，搶佔系統資源從而導致阻塞。

線程池優點

我們將線程放入線程池，由線程池對線程進行管理，可以對線程池中緩衝的線程進行復用，這樣，就不會經常去創建和銷毀線程了，從而省下了系統的資源。

線程池能夠有效的控制線程併發的數量，能夠解決多線程造成的併發問題。

除此之外，線程池還能夠對線程進行一定的管理，如延時執行、定時循環執行的策略等

線程池實現

線程池的實現，主要是通過這個類ThreadPoolExecutor，其的構造參數非常長，我們先大概了解，之後再進行詳細的介紹。

public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,long keepAliveTime,
    TimeUnit unit,BlockingQueue workQueue,
    RejectedExecutionHandler handler)

• corePoolSize：線程池核心線程數量
• maximumPoolSize：線程池最大線程數量
• keepAliverTime：當活躍線程數大於核心線程數時，空閑的多餘線程最大存活時間
• unit：存活時間的單位
• workQueue：存放線程的工作隊列
• handler：超出線程範圍和隊列容量的任務的處理程序（拒絕策略）

這裏大概簡單說明一下線程池的運行流程：

當線程被添加到線程池中，如果線程池中的當前的線程數量等於線程池定義的最大核心線程數量（corePoolSize)了，此線程就會別放入線程的工作隊列(workQueue)中，等待線程池的調用。

Java提供了一個工具類Excutors，方便我們快速創建線程池，其底層也是調用了ThreadPoolExecutor

不過阿里巴巴Java規範中強制要求我們應該通過ThreadPoolExecutor來創建自己的線程池，使用Excutors容易造成OOM問題。

所以，我們先從Excutors開始學習，之後在對ThreadPoolExecutor進行詳細的講解

Excutors

由於Excutors是工具類，所以下面的介紹的都是其的靜態方法，如果是比較線程數目比較少的小項目，可以使用此工具類來創建線程池

PS：把線程提交給線程池中，有兩種方法，一種是submit，另外一種則是execute

兩者的區別：

1. execute沒有返回值，如果不需要知道線程的結果就使用execute方法，性能會好很多。
2. submit返回一個Future對象，如果想知道線程結果就使用submit提交，而且它能在主線程中通過Future的get方法捕獲線程中的異常

線程池可以接收兩種的參數，一個為Runnable對象，另外則是Callable對象

Callable是JDK1.5時加入的接口，作為Runnable的一種補充，允許有返回值，允許拋出異常。

主要的幾個靜態方法：

1.newSingleThreadExecutor

創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行，我們可以使用它來達到控制線程順序執行。

控制進程順序執行：

Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("這是線程1");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            System.out.println("這是線程2");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
Thread thread3 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            System.out.println("這是線程3");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
//創建線程池對象
ExecutorService executorService = Executors.newSingleThreadExecutor();
//把線程添加到線程池中
executorService.submit(thread1);
executorService.submit(thread2);
executorService.submit(thread3);

之後出現的結果就是按照順序輸出

2.newFixedThreadPool

創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

3.newCachedThreadPool

創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程，線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。

代碼：

//創建了一個自定義的線程
public class MyThread extends Thread {
    private int index;

    public MyThread(int index) {
        this.index = index;
    }

    @Override
    public void run() {
        System.out.println(index+" 當前線程"+Thread.currentThread().getName());
    }
}

//創建緩存線程池
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
    executorService.execute(new MyThread(i));
    try {
        //這裏模擬等待時間，等待線程池復用回收線程
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

可以看到結果都是使用的同一個線程

4.newScheduledThreadPool

創建一個定長線程池，支持定時、周期性或延時任務執行

延遲1s后啟動線程：

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
scheduledExecutorService.schedule(new MyThread(1),1, TimeUnit.SECONDS);

ThreadPoolExecutor

構造方法

上面提到的那個構造方法其實只是ThreadPoolExecutor類中的一個，ThreadPoolExecutor類中存在有四種不同的構造方法，主要區別就是參數不同。

//五個參數的構造函數
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

//六個參數的構造函數-1
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

//六個參數的構造函數-2
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)

//七個參數的構造函數
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

首先，有個概念需要明白，線程池的最大線程數（線程總數,maximumPoolSize）= 核心線程數(corePoolSize)+非核心線程數

• corePoolSize：線程池核心線程數量
• maximumPoolSize：線程池最大線程數量
• keepAliverTime：當活躍線程數大於核心線程數時，空閑的多餘線程最大存活時間
• unit：存活時間的單位
• workQueue：存放線程的工作隊列
• handler：超出線程範圍和隊列容量的任務的處理程序（拒絕策略）

核心線程和非核心線程有什麼區別呢？

核心線程是永遠不會被線程池丟棄回收（即使核心線程沒有工作），非核心線程則是超過一定時間（keepAliverTime)則就會被丟棄

workQueue

當所有的核心線程都在工作時，新添加的任務會被添加到這個隊列中等待處理，如果隊列滿了，則新建非核心線程執行任務

1.SynchronousQueue：這個隊列接收到任務的時候，會直接提交給線程處理，而不保留它，如果所有線程都在工作怎麼辦？那就新建一個線程來處理這個任務！所以為了保證不出現線程數達到了maximumPoolSize而不能新建線程的錯誤，使用這個類型隊列的時候，maximumPoolSize一般指定成Integer.MAX_VALUE，即無限大

2.LinkedBlockingQueue：這個隊列接收到任務的時候，如果當前線程數小於核心線程數，則新建線程(核心線程)處理任務；如果當前線程數等於核心線程數，則進入隊列等待。由於這個隊列沒有最大值限制，即所有超過核心線程數的任務都將被添加到隊列中，這也就導致了maximumPoolSize的設定失效，因為總線程數永遠不會超過corePoolSize

3.ArrayBlockingQueue：可以限定隊列的長度，接收到任務的時候，如果沒有達到corePoolSize的值，則新建線程(核心線程)執行任務，如果達到了，則入隊等候，如果隊列已滿，則新建線程(非核心線程)執行任務，又如果總線程數到了maximumPoolSize，並且隊列也滿了，則發生錯誤

4.DelayQueue：隊列內元素必須實現Delayed接口，這就意味着你傳進去的任務必須先實現Delayed接口。這個隊列接收到任務時，首先先入隊，只有達到了指定的延時時間，才會執行任務

拒絕策略：

兩種方法設置拒絕策略：

//ThreadPoolExecutor對象的setRejectedExecutionHandler方法設置
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 5, 60, TimeUnit.SECONDS, queue);
threadPool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
//構造方法進行設置，省略

線程池默認的拒絕行為是AbortPolicy，也就是拋出RejectedExecutionHandler異常，該異常是非受檢異常，很容易忘記捕獲。

如果不關心任務被拒絕的事件，可以將拒絕策略設置成DiscardPolicy，這樣多餘的任務會悄悄的被忽略。

ThreadFactory

一個接口類，用來對線程進行設置，需要實現newThread(Runnable r)方法

官方的文檔說明:

newThread此方法一般來初始化線程的優先級(priority)，名字(name)，守護進程(daemon)或線程組(ThreadGroup)

簡單的例子（讓某個類實現ThreadFactory接口）：

@Override
public Thread newThread(Runnable r) {
    Thread thread = new Thread(r);
    thread.setDaemon(true);
    return thread;
}

線程池獲取執行結果

PS：把線程提交給線程池中，有兩種方法，一種是submit，另外一種則是execute

兩者的區別：

1. execute沒有返回值，如果不需要知道線程的結果就使用execute方法，性能會好很多。
2. submit返回一個Future對象，如果想知道線程結果就使用submit提交，而且它能在主線程中通過Future的get方法捕獲線程中的異常

線程池可以接收兩種的參數，一個為Runnable對象，另外則是Callable對象

Callable是JDK1.5時加入的接口，作為Runnable的一種補充，允許有返回值，允許拋出異常。

線程池的處理結果、以及處理過程中的異常都被包裝到Future中，並在調用Future.get()方法時獲取，執行過程中的異常會被包裝成ExecutionException，submit()方法本身不會傳遞結果和任務執行過程中的異常。

獲取執行結果的代碼可以這樣寫：

ExecutorService executorService = Executors.newFixedThreadPool(4);
Future<Object> future = executorService.submit(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            //該異常會在調用Future.get()時傳遞給調用者
            throw new RuntimeException("exception in call~");
        }
    });
    
try {
    //獲得返回結果
    Object result = future.get();
    
    
} catch (InterruptedException e) {
  // interrupt
} catch (ExecutionException e) {
  // exception in Callable.call()
  e.printStackTrace();
}

線程池運行流程

一個形象的比喻說明線程池的流程：

規定：

1. 線程池比作成一家公司
2. 公司的最大員工數為maximumPoolSize
3. 最大正式員工數為coolPoolSize（核心線程的總數）
4. 最大員工數（maximumPoolSize） = 最大正式員工（coolPoolSize）和臨時工（非核心線程）
5. 單子（任務）可看做為線程
6. 隊列使用的是ArrayBlockingQueue
7. 一個員工只能幹一個任務

最開始的時候，公司是沒有一名員工。之後，公司接到了單子（任務），這個時候，公司才去找員工（創建核心線程並讓線程開始執行），這個時候找到的員工就是正式員工了。

公司的聲譽越來越好，於是來了更多的單子，公司繼續招人，直到正式員工數量達到最大的正式員工的數量（核心線程數量已達到最大）

於是，多出來的單子就暫時地存放在了隊列中，都在排隊，等待正式員工們把手頭的工作做完之後，就從隊列中依次取出單子繼續工作。

某天，來了一個新單子，但是這個時候隊列已經滿了，公司為了自己的信譽和聲譽着想，不得已只能去找臨時工（創建非核心線程）來幫忙開始進行工作（負責新單子）

在此之後，又來了新單子，公司繼續去招臨時工為新來的單子工作，直到正式工和臨時工的數量已經達到了公司最大員工數。

這個時候，公司沒有辦法了，只能拒絕新來的單子了（拒絕策略）

此時，正式工和臨時工都是在加班加點去從隊列中取出任務來工作，終於某一天，隊列的已經沒有單子了，市場發展不好，單子越來越少，臨時工很久都不工作了（非核心線程超過了最大存活時間keepAliveTime)，公司就把這些臨時工解僱了，直到剩下只有正式員工。

PS:如果也想要解僱正式員工(銷毀核心線程)，可以設置ThreadPoolExecutor對象的的allowCoreThreadTimeOut這個屬性為true

個人理解，可能不是很正確，僅供參考！

線程池關閉

總結

如果是小的Java程序，可以使用Excutors，如果是服務器程序，則使用ThreadPoolExecutor進行自定義線程池的創建

參考鏈接：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※USB CONNECTOR 掌控什麼技術要點? 帶您認識其相關發展及效能

※高價3c回收,收購空拍機,收購鏡頭,收購 MACBOOK-更多收購平台討論專區

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※收購3c瘋!各款手機、筆電、相機、平板,歡迎來詢價!

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選