資料庫連接池什麼時候會創建線程

❶ 並發編程解惑之線程

主要內容：

進程是資源分配的最小單位，每個進程都有獨立的代碼和數據空間，一個進程包含 1 到 n 個線程。線程是 CPU 調度的最小單位，每個線程有獨立的運行棧和程序計數器，線程切換開銷小。

java 程序總是從主類的 main 方法開始執行，main 方法就是 Java 程序默認的主線程，而在 main 方法中再創建的線程就是其他線程。在 Java 中，每次程序啟動至少啟動 2 個線程。一個是 main 線程，一個是垃圾收集線程。每次使用 Java 命令啟動一個 Java 程序，就相當於啟動一個 JVM 實例，而每個 JVM 實例就是在操作系統中啟動的一個進程。

多線程可以通過繼承或實現介面的方式創建。

Thread 類是 JDK 中定義的用於控制線程對象的類，該類中封裝了線程執行體 run() 方法。需要強調的一點是，線程執行先後與創建順序無關。

通過 Runnable 方式創建線程相比通過繼承 Thread 類創建線程的優勢是避免了單繼承的局限性。若一個 boy 類繼承了 person 類，boy 類就無法通過繼承 Thread 類的方式來實現多線程。

使用 Runnable 介面創建線程的過程：先是創建對象實例 MyRunnable，然後將對象 My Runnable 作為 Thread 構造方法的入參，來構造出線程。對於 new Thread(Runnable target) 創建的使用同一入參目標對象的線程，可以共享該入參目標對象 MyRunnable 的成員變數和方法，但 run() 方法中的局部變數相互獨立，互不幹擾。

上面代碼是 new 了三個不同的 My Runnable 對象，如果只想使用同一個對象，可以只 new 一個 MyRunnable 對象給三個 new Thread 使用。

實現 Runnable 介面比繼承 Thread 類所具有的優勢：

線程有新建、可運行、阻塞、等待、定時等待、死亡 6 種狀態。一個具有生命的線程，總是處於這 6 種狀態之一。 每個線程可以獨立於其他線程運行，也可和其他線程協同運行。線程被創建後，調用 start() 方法啟動線程，該線程便從新建態進入就緒狀態。

NEW 狀態（新建狀態） 實例化一個線程之後，並且這個線程沒有開始執行，這個時候的狀態就是 NEW 狀態：

RUNNABLE 狀態（就緒狀態）：

阻塞狀態有 3 種：

如果一個線程調用了一個對象的 wait 方法， 那麼這個線程就會處於等待狀態（waiting 狀態）直到另外一個線程調用這個對象的 notify 或者 notifyAll 方法後才會解除這個狀態。

run() 里的代碼執行完畢後，線程進入終結狀態（TERMINATED 狀態）。

線程狀態有 6 種：新建、可運行、阻塞、等待、定時等待、死亡。

我們看下 join 方法的使用：

運行結果：

我們來看下 yield 方法的使用：

運行結果：

線程與線程之間是無法直接通信的，A 線程無法直接通知 B 線程，Java 中線程之間交換信息是通過共享的內存來實現的，控制共享資源的讀寫的訪問，使得多個線程輪流執行對共享數據的操作，線程之間通信是通過對共享資源上鎖或釋放鎖來實現的。線程排隊輪流執行共享資源，這稱為線程的同步。

Java 提供了很多同步操作（也就是線程間的通信方式），同步可使用 synchronized 關鍵字、Object 類的 wait/notifyAll 方法、ReentrantLock 鎖、無鎖同步 CAS 等方式來實現。

ReentrantLock 是 JDK 內置的一個鎖對象，用於線程同步（線程通信），需要用戶手動釋放鎖。

運行結果：

這表明同一時間段只能有 1 個線程執行 work 方法，因為 work 方法里的代碼需要獲取到鎖才能執行，這就實現了多個線程間的通信，線程 0 獲取鎖，先執行，線程 1 等待，線程 0 釋放鎖，線程 1 繼續執行。

synchronized 是一種語法級別的同步方式，稱為內置鎖。該鎖會在代碼執行完畢後由 JVM 釋放。

輸出結果跟 ReentrantLock 一樣。

Java 中的 Object 類默認是所有類的父類，該類擁有 wait、 notify、notifyAll 方法，其他對象會自動繼承 Object 類，可調用 Object 類的這些方法實現線程間的通信。

除了可以通過鎖的方式來實現通信，還可通過無鎖的方式來實現，無鎖同 CAS（Compare-and-Swap，比較和交換）的實現，需要有 3 個操作數：內存地址 V，舊的預期值 A，即將要更新的目標值 B，當且僅當內存地址 V 的值與預期值 A 相等時，將內存地址 V 的值修改為目標值 B，否則就什麼都不做。

我們通過計算器的案例來演示無鎖同步 CAS 的實現方式，非線程安全的計數方式如下：

線程安全的計數方式如下：

運行結果：

線程安全累加的結果才是正確的，非線程安全會出現少計算值的情況。JDK 1.5 開始，並發包里提供了原子操作的類，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 還提供了用原子方式將當前值自增 1 或自減 1 的方法，在多線程程序中，諸如 ++i 或 i++ 等運算不具有原子性，是不安全的線程操作之一。 通常我們使用 synchronized 將該操作變成一個原子操作，但 JVM 為此種操作提供了原子操作的同步類 Atomic，使用 AtomicInteger 做自增運算的性能是 ReentantLock 的好幾倍。

上面我們都是使用底層的方式實現線程間的通信的，但在實際的開發中，我們應該盡量遠離底層結構，使用封裝好的 API，例如 J.U.C 包（java.util.concurrent，又稱並發包）下的工具類 CountDownLath、CyclicBarrier、Semaphore，來實現線程通信，協調線程執行。

CountDownLatch 能夠實現線程之間的等待，CountDownLatch 用於某一個線程等待若干個其他線程執行完任務之後，它才開始執行。

CountDownLatch 類只提供了一個構造器：

CountDownLatch 類中常用的 3 個方法：

運行結果：

CyclicBarrier 字面意思循環柵欄，通過它可以讓一組線程等待至某個狀態之後再全部同時執行。當所有等待線程都被釋放以後，CyclicBarrier 可以被重復使用，所以有循環之意。

相比 CountDownLatch，CyclicBarrier 可以被循環使用，而且如果遇到線程中斷等情況時，可以利用 reset() 方法，重置計數器，CyclicBarrier 會比 CountDownLatch 更加靈活。

CyclicBarrier 提供 2 個構造器：

上面的方法中，參數 parties 指讓多少個線程或者任務等待至 barrier 狀態；參數 barrierAction 為當這些線程都達到 barrier 狀態時會執行的內容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 個重載版本。下面方法用來掛起當前線程，直至所有線程都到達 barrier 狀態再同時執行後續任務。

而下面的方法則是讓這些線程等待至一定的時間，如果還有線程沒有到達 barrier 狀態就直接讓到達 barrier 的線程執行任務。

運行結果：

CyclicBarrier 用於一組線程互相等待至某個狀態，然後這一組線程再同時執行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 類是一個計數信號量，它可以設定一個閾值，多個線程競爭獲取許可信號，執行完任務後歸還，超過閾值後，線程申請許可信號時將會被阻塞。Semaphore 可以用來 構建對象池，資源池，比如資料庫連接池。

假如在伺服器上運行著若干個客戶端請求的線程。這些線程需要連接到同一資料庫，但任一時刻只能獲得一定數目的資料庫連接。要怎樣才能夠有效地將這些固定數目的資料庫連接分配給大量的線程呢？

給方法加同步鎖，保證同一時刻只能有一個線程去調用此方法，其他所有線程排隊等待，但若有 10 個資料庫連接，也只有一個能被使用，效率太低。另外一種方法，使用信號量，讓信號量許可與資料庫可用連接數為相同數量，10 個資料庫連接都能被使用，大大提高性能。

上面三個工具類是 J.U.C 包的核心類，J.U.C 包的全景圖就比較復雜了：

J.U.C 包（java.util.concurrent）中的高層類（Lock、同步器、阻塞隊列、Executor、並發容器）依賴基礎類（AQS、非阻塞數據結構、原子變數類），而基礎類是通過 CAS 和 volatile 來實現的。我們盡量使用頂層的類，避免使用基礎類 CAS 和 volatile 來協調線程的執行。J.U.C 包其他的內容，在其他的篇章會有相應的講解。

Future 是一種非同步執行的設計模式，類似 ajax 非同步請求，不需要同步等待返回結果，可繼續執行代碼。使 Runnable（無返回值不支持上報異常）或 Callable（有返回值支持上報異常）均可開啟線程執行任務。但是如果需要非同步獲取線程的返回結果，就需要通過 Future 來實現了。

Future 是位於 java.util.concurrent 包下的一個介面，Future 介面封裝了取消任務，獲取任務結果的方法。

在 Java 中，一般是通過繼承 Thread 類或者實現 Runnable 介面來創建多線程， Runnable 介面不能返回結果，JDK 1.5 之後，Java 提供了 Callable 介面來封裝子任務，Callable 介面可以獲取返回結果。我們使用線程池提交 Callable 介面任務，將返回 Future 介面添加進 ArrayList 數組，最後遍歷 FutureList，實現非同步獲取返回值。

運行結果：

上面就是非同步線程執行的調用過程，實際開發中用得更多的是使用現成的非同步框架來實現非同步編程，如 RxJava，有興趣的可以繼續去了解，通常非同步框架都是結合遠程 HTTP 調用 Retrofit 框架來使用的，兩者結合起來用，可以避免調用遠程介面時，花費過多的時間在等待介面返回上。

線程封閉是通過本地線程 ThreadLocal 來實現的，ThreadLocal 是線程局部變數（local vari able），它為每個線程都提供一個變數值的副本，每個線程對該變數副本的修改相互不影響。

在 JVM 虛擬機中，堆內存用於存儲共享的數據（實例對象），也就是主內存。Thread Local .set()、ThreadLocal.get() 方法直接在本地內存（工作內存）中寫和讀共享變數的副本，而不需要同步數據，不用像 synchronized 那樣保證數據可見性，修改主內存數據後還要同步更新到工作內存。

Myabatis、hibernate 是通過 threadlocal 來存儲 session 的，每一個線程都維護著一個 session，對線程獨享的資源操作很方便，也避免了線程阻塞。

ThreadLocal 類位於 Thread 線程類內部，我們分析下它的源碼：

ThreadLocal 和 Synchonized 都用於解決多線程並發訪問的問題，訪問多線程共享的資源時，Synchronized 同步機制採用了以時間換空間的方式，提供一份變數讓多個線程排隊訪問，而 ThreadLocal 採用了以空間換時間的方式，提供每個線程一個變數，實現數據隔離。

ThreadLocal 可用於資料庫連接 Connection 對象的隔離，使得每個請求線程都可以復用連接而又相互不影響。

在 Java 裡面，存在強引用、弱引用、軟引用、虛引用。我們主要來了解下強引用和弱引用：

上面 a、b 對實例 A、B 都是強引用

而上面這種情況就不一樣了，即使 b 被置為 null，但是 c 仍然持有對 C 對象實例的引用，而間接的保持著對 b 的強引用，所以 GC 不會回收分配給 b 的空間，導致 b 無法回收也沒有被使用，造成了內存泄漏。這時可以通過 c = null; 來使得 c 被回收，但也可以通過弱引用來達到同樣目的：

從源碼中可以看出 Entry 里的 key 對 ThreadLocal 實例是弱引用：

Entry 里的 key 對 ThreadLocal 實例是弱引用，將 key 值置為 null，堆中的 ThreadLocal 實例是可以被垃圾收集器（GC）回收的。但是 value 卻存在一條從 Current Thread 過來的強引用鏈，只有當當前線程 Current Thread 銷毀時，value 才能被回收。在 threadLocal 被設為 null 以及線程結束之前，Entry 的鍵值對都不會被回收，出現內存泄漏。為了避免泄漏，在 ThreadLocalMap 中的 set/get Entry 方法里，會對 key 為 null 的情況進行判斷，如果為 null 的話，就會對 value 置為 null。也可以通過 ThreadLocal 的 remove 方法（類似加鎖和解鎖，最後 remove 一下，解鎖對象的引用）直接清除，釋放內存空間。

總結來說，利用 ThreadLocal 來訪問共享數據時，JVM 通過設置 ThreadLocalMap 的 Key 為弱引用，來避免內存泄露，同時通過調用 remove、get、set 方法的時候，回收弱引用（Key 為 null 的 Entry）。當使用 static ThreadLocal 的時候（如上面的 Spring 多數據源），static 變數在類未載入的時候，它就已經載入，當線程結束的時候，static 變數不一定會被回收，比起普通成員變數使用的時候才載入，static 的生命周期變長了，若沒有及時回收，容易產生內存泄漏。

使用線程池，可以重用存在的線程，減少對象創建、消亡的開銷，可控制最大並發線程數，避免資源競爭過度，還能實現線程定時執行、單線程執行、固定線程數執行等功能。

Java 把線程的調用封裝成了一個 Executor 介面，Executor 介面中定義了一個 execute 方法，用來提交線程的執行。Executor 介面的子介面是 ExecutorService，負責管理線程的執行。通過 Executors 類的靜態方法可以初始化

ExecutorService 線程池。Executors 類的靜態方法可創建不同類型的線程池：

但是，不建議使用 Executors 去創建線程池，而是通過 ThreadPoolExecutor 的方式，明確給出線程池的參數去創建，規避資源耗盡的風險。

如果使用 Executors 去創建線程池：

最佳的實踐是通過 ThreadPoolExecutor 手動地去創建線程池，選取合適的隊列存儲任務，並指定線程池線程大小。通過線程池實現類 ThreadPoolExecutor 可構造出線程池的，構造函數有下面幾個重要的參數：

參數 1：corePoolSize

線程池核心線程數。

參數 2：workQueue

阻塞隊列，用於保存執行任務的線程，有 4 種阻塞隊列可選：

參數 3：maximunPoolSize

線程池最大線程數。如果阻塞隊列滿了（有界的阻塞隊列），來了一個新的任務，若線程池當前線程數小於最大線程數，則創建新的線程執行任務，否則交給飽和策略處理。如果是無界隊列就不存在這種情況，任務都在無界隊列里存儲著。

參數 4：RejectedExecutionHandler

拒絕策略，當隊列滿了，而且線程達到了最大線程數後，對新任務採取的處理策略。

有 4 種策略可選：

最後，還可以自定義處理策略。

參數 5：ThreadFactory

創建線程的工廠。

參數 6：keeyAliveTime

線程沒有任務執行時最多保持多久時間終止。當線程池中的線程數大於 corePoolSize 時，線程池中所有線程中的某一個線程的空閑時間若達到 keepAliveTime，則會終止，直到線程池中的線程數不超過 corePoolSize。但如果調用了 allowCoreThread TimeOut(boolean value) 方法，線程池中的線程數就算不超過 corePoolSize，keepAlive Time 參數也會起作用，直到線程池中的線程數量變為 0。

參數 7：TimeUnit

配合第 6 個參數使用，表示存活時間的時間單位最佳的實踐是通過 ThreadPoolExecutor 手動地去創建線程池，選取合適的隊列存儲任務，並指定線程池線程大小。

運行結果：

線程池創建線程時，會將線程封裝成工作線程 Worker，Worker 在執行完任務後，還會不斷的去獲取隊列里的任務來執行。Worker 的加鎖解鎖機制是繼承 AQS 實現的。

我們來看下 Worker 線程的運行過程：

總結來說，如果當前運行的線程數小於 corePoolSize 線程數，則獲取全局鎖，然後創建新的線程來執行任務如果運行的線程數大於等於 corePoolSize 線程數，則將任務加入阻塞隊列 BlockingQueue 如果阻塞隊列已滿，無法將任務加入 BlockingQueue，則獲取全局所，再創建新的線程來執行任務

如果新創建線程後使得線程數超過了 maximumPoolSize 線程數，則調用 Rejected ExecutionHandler.rejectedExecution() 方法根據對應的拒絕策略處理任務。

CPU 密集型任務，線程執行任務佔用 CPU 時間會比較長，應該配置相對少的線程數，避免過度爭搶資源，可配置 N 個 CPU+1 個線程的線程池；但 IO 密集型任務則由於需要等待 IO 操作，線程經常處於等待狀態，應該配置相對多的線程如 2*N 個 CPU 個線程，A 線程阻塞後，B 線程能馬上執行，線程多競爭激烈，能飽和的執行任務。線程提交 SQL 後等待資料庫返回結果時間較長的情況，CPU 空閑會較多，線程數應設置大些，讓更多線程爭取 CPU 的調度。

❷ Java開發常用的幾個資料庫連接池

資料庫連接池的好處是不言而喻的，現在大部分的application
server都提供自己的資料庫連接池方案，此時，只要按照application server的文檔說明，正確配置，即可在應用中享受到資料庫連接池的好處。

但是，有些時候，我們的應用是個獨立的java
application，並不是普通的WEB/J2EE應用，而且是單獨運行的，不要什麼application
server的配合，這種情況下，我們就需要建立自己的資料庫連接池方案了。

1、 DBCP

DBCP是Apache的一個開源項目：
commons.dbcp

DBCP依賴Apache的另外2個開源項目
commons.collections和commons.pool

dbcp包，目前版本是1.2.1：http://jakarta.apache.org/commons/dbcp/

pool包，目前版本是1.3：http://jakarta.apache.org/commons/pool/，

common-collections包：http://jakarta.apache.org/commons/collections/

下載這些包並將這些包的路徑添加到classpath中就可以使用dbcp做為項目中的資料庫連接池使用了。

在建立我們自己的資料庫連接池時，可以使用xml文件來傳入需要的參數，這里只使用hard
code的方式來簡單介紹，所有需要我們自己寫的代碼很少，只要建立一個文件如下：
import
org.apache.commons.dbcp.BasicDataSource;
import
org.apache.commons.dbcp.BasicDataSourceFactory;
import
java.sql.SQLException;
import java.sql.Connection;
import
java.util.Properties;

public class ConnectionSource {

private static BasicDataSource dataSource =
null;

public ConnectionSource() {
}

public static void init() {

if (dataSource != null) {
try
{
dataSource.close();
} catch (Exception e)
{
}

dataSource = null;
}

try {
Properties p = new
Properties();

p.setProperty("driverClassName",
"oracle.jdbc.driver.OracleDriver");
p.setProperty("url",
"jdbc:oracle:thin:@192.168.0.1:1521:testDB");

p.setProperty("password", "scott");
p.setProperty("username",
"tiger");
p.setProperty("maxActive", "30");

p.setProperty("maxIdle", "10");
p.setProperty("maxWait",
"1000");
p.setProperty("removeAbandoned",
"false");
p.setProperty("removeAbandonedTimeout",
"120");
p.setProperty("testOnBorrow", "true");

p.setProperty("logAbandoned", "true");

dataSource = (BasicDataSource)
BasicDataSourceFactory.createDataSource(p);

} catch (Exception e) {
}

}

public static synchronized Connection
getConnection() throws SQLException {

if (dataSource == null) {

init();
}

Connection conn = null;

if (dataSource != null) {

conn = dataSource.getConnection();
}

return conn;
}
}

接下來，在我們的應用中，只要簡單地使用ConnectionSource.getConnection()就可以取得連接池中的資料庫連接，享受資料庫連接帶給我們的好處了。當我們使用完取得的資料庫連接後，只要簡單地使用connection.close()就可把此連接返回到連接池中，至於為什麼不是直接關閉此連接，而是返回給連接池，這是因為dbcp使用委派模型來實現Connection介面了。

在使用Properties來創建BasicDataSource時，有很多參數可以設置，比較重要的還有：

testOnBorrow、testOnReturn、testWhileIdle，他們的意思是當是取得連接、返回連接或連接空閑時是否進行有效性驗證（即是否還和資料庫連通的），默認都為false。所以當資料庫連接因為某種原因斷掉後，再從連接池中取得的連接，實際上可能是無效的連接了，所以，為了確保取得的連接是有效的，
可以把把這些屬性設為true。當進行校驗時，需要另一個參數：validationQuery，對oracle來說，可以是：SELECT COUNT(*) FROM
DUAL，實際上就是個簡單的SQL語句，驗證時，就是把這個SQL語句在資料庫上跑一下而已，如果連接正常的，當然就有結果返回了。

還有2個參數：timeBetweenEvictionRunsMillis 和
minEvictableIdleTimeMillis，
他們兩個配合，可以持續更新連接池中的連接對象，當timeBetweenEvictionRunsMillis
大於0時，每過timeBetweenEvictionRunsMillis
時間，就會啟動一個線程，校驗連接池中閑置時間超過minEvictableIdleTimeMillis的連接對象。

還有其他的一些參數，可以參考源代碼。

2、
C3P0:

C3P0是一個開放源代碼的JDBC連接池，C3PO
連接池是一個優秀的連接池，推薦使用。C3PO實現了JDBC3.0規范的部分功能，因而性能更加突出,包括了實現jdbc3和jdbc2擴展規范說明的Connection 和Statement 池的DataSources 對象。
下載地址:http://sourceforge.net/projects/c3p0

package
com.systex.utils.web;

import java.beans.PropertyVetoException;
import
java.sql.Connection;
import java.sql.SQLException;
import
javax.sql.DataSource;
import
com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3PODataSource {
private static
ComboPooledDataSource dataSource = null;
private static final String driver
= "com.mysql.jdbc.Driver";
private static final String url =
"jdbc:mysql://localhost:3306/wyd";
private static final String userName =
"root";
private static final String password = "root";

public static DataSource getDataSource() {
if
(dataSource == null) {
dataSource = new ComboPooledDataSource();
try
{
dataSource.setDriverClass(driver);
} catch (PropertyVetoException
e) {
System.out.println("DataSource Load Driver
Exception!!");
e.printStackTrace();
}
dataSource.setJdbcUrl(url);
dataSource.setUser(userName);
dataSource.setPassword(password);
//
設置連接池最大連接容量
dataSource.setMaxPoolSize(20);
//
設置連接池最小連接容量
dataSource.setMinPoolSize(2);
//
設置連接池最大statements對象容量
dataSource.setMaxStatements(100);
}
return
dataSource;
}

public static Connection getConnection() throws
SQLException {
return
C3PODataSource.getDataSource().getConnection();
}
}

3、 Proxool

這是一個Java SQL
Driver驅動程序，提供了對你選擇的其它類型的驅動程序的連接池封裝。可以非常簡單的移植到現存的代碼中。完全可配置。快速，成熟，健壯。可以透明地為你現存的JDBC驅動程序增加連接池功能。

官方網站: http://proxool.sourceforge.net/

下載地址:http://proxool.sourceforge.net/download.html

❸ MySQL與Redis資料庫連接池介紹（圖示+源碼+代碼演示）

資料庫連接池（Connection pooling）是程序啟動時建立足夠的資料庫連接，並將這些連接組成一個連接池，由程序動態地對池中的連接進行申請，使用，釋放。

簡單的說：創建資料庫連接是一個很耗時的操作，也容易對資料庫造成安全隱患。所以，在程序初始化的時候，集中創建多個資料庫連接，並把他們集中管理，供程序使用，可以保證較快的資料庫讀寫速度，還更加安全可靠。

不使用資料庫連接池

如果不使用資料庫連接池，對於每一次SQL操作，都要走一遍下面完整的流程：

1.TCP建立連接的三次握手（客戶端與 MySQL伺服器的連接基於TCP協議）

2.MySQL認證的三次我收

3.真正的SQL執行

4.MySQL的關閉

5.TCP的四次握手關閉

可以看出來，為了執行一條SQL，需要進行大量的初始化與關閉操作

使用資料庫連接池

如果使用資料庫連接池，那麼會 事先申請（初始化）好 相關的資料庫連接，然後在之後的SQL操作中會復用這些資料庫連接，操作結束之後資料庫也不會斷開連接，而是將資料庫對象放回到資料庫連接池中

資源重用：由於資料庫連接得到重用，避免了頻繁的創建、釋放連接引起的性能開銷，在減少系統消耗的基礎上，另一方面也增進了系統運行環境的平穩性（減少內存碎片以及資料庫臨時進程/線程的數量）。

更快的系統響應速度：資料庫連接池在初始化過程中，往往已經創建了若干資料庫連接置於池中備用。 此時連接的初始化工作均已完成。對於業務請求處理而言，直接利用現有可用連接，避免了從資料庫連接初始化和釋放過程的開銷，從而縮減了系統整體響應時間。

統一的連接管理，避免資料庫連接泄露：在較為完備的資料庫連接池實現中，可根據預先的連接佔用超時設定，強制收回被佔用連接。從而避免了常規資料庫連接操作中可能出現的資源泄露。

如果說你的伺服器CPU是4核i7的，連接池大小應該為((4*2)+1)=9

相關視頻推薦

90分鍾搞懂資料庫連接池技術|linux後台開發

《tcp/ip詳解卷一》： 150行代碼拉開協議棧實現的篇章

學習地址：C/C++Linux伺服器開發/後台架構師【零聲教育】-學習視頻教程-騰訊課堂

需要C/C++ Linux伺服器架構師學習資料加qun 812855908 獲取（資料包括 C/C++，Linux，golang技術，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg 等），免費分享

源碼下載

下載方式：https://github.com/dongyusheng/csdn-code/tree/master/db_pool（Github中下載）

db_pool目錄下有兩個目錄，mysql_pool目錄為MySQL連接池代碼，redis_pool為redis連接池代碼

下面介紹mysql_pool

CDBConn解析

概念： 代表一個數據連接對象實例

相關成員：

m_pDBPool：該資料庫連接對象所屬的資料庫連接池

構造函數： 綁定自己所屬於哪個資料庫連接池

Init()函數： 創建資料庫連接句柄

CDBPool解析

概念：代表一個資料庫連接池

相關成員：

Init()函數：常見指定數量的資料庫實例句柄，然後添加到m_free_list中，供後面使用

GetDBConn()函數： 用於從空閑隊列中返回可以使用的資料庫連接句柄

RelDBConn()函數： 程序使用完該資料庫句柄之後，將句柄放回到空閑隊列中

測試之前，將代碼中的資料庫地址、埠、賬號密碼等改為自己的（代碼中有好幾處）

進入MySQL， 創建mysql_pool_test資料庫

進入到mysql_pool目錄下， 創建一個build目錄並進入 ：

然後輸入如下的命令進行編譯

之後就會在目錄下生成如下的可執行文件

輸入如下兩條命令進行測試： 可以看到不使用資料庫連接池，整個操作耗時4秒左右；使用連接池之後，整個操作耗時2秒左右，提升了一倍

源碼下載

下面介紹redis_pool

測試

進入到redis_pool目錄下， 創建一個build目錄並進入 ：

然後輸入如下的命令進行編譯

之後就會在目錄下生成如下的可執行文件

輸入如下的命令進行測試： 可以看到不使用資料庫連接池，整個操作耗時182ms；使用連接池之後，整個操作耗時21ms，提升了很多

進入redis，可以看到我們新建的key：

❹ 啥時候會使用線程池

編者註：Java中的線程池是運用場景最多的並發組件，幾乎所有需要非同步或並發執行任務的程序都可以使用線程池。

在開發過程中，合理地使用線程池能夠帶來至少以下幾個好處。

降低資源消耗：通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
提高響應速度：當任務到達時，任務可以不需要等到線程創建就能立即執行。
提高線程的可管理性：線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。但是，要做到合理利用線程池，必須了解其實現原理。
代碼解耦：比如生產者消費者模式。
線程池實現原理
當提交一個新任務到線程池時，線程池的處理流程如下：

如果當前運行的線程少於corePoolSize，則創建新線程來執行任務（注意，執行這一步驟需要獲取全局鎖）。
如果運行的線程等於或多於corePoolSize，則將任務加入BlockingQueue。
如果無法將任務加入BlockingQueue（隊列已滿），則創建新的線程來處理任務（注意，執行這一步驟也需要獲取全局鎖）。
如果創建新線程將使當前運行的線程數超出maximumPoolSize，該任務將被拒絕，並調用相應的拒絕策略來處理（RejectedExecutionHandler.rejectedExecution()方法，線程池默認的飽和策略是AbortPolicy，也就是拋異常）。
ThreadPoolExecutor採取上述步驟的總體設計思路，是為了在執行execute()方法時，盡可能地避免獲取全局鎖（那將會是一個嚴重的可伸縮瓶頸）。在ThreadPoolExecutor完成預熱之後（當前運行的線程數大於等於corePoolSize），幾乎所有的execute()方法調用都是執行步驟2，而步驟2不需要獲取全局鎖。

線程池任務 拒絕策略包括 拋異常、直接丟棄、丟棄隊列中最老的任務、將任務分發給調用線程處理。

線程池的創建：通過ThreadPoolExecutor來創建一個線程池。

new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, timeUnit, runnableTaskQueue, handler);
創建一個線程池時需要輸入以下幾個參數：

corePoolSize（線程池的基本大小）：當提交一個任務到線程池時，線程池會創建一個線程來執行任務，即使其他空閑的基本線程能夠執行新任務也會創建線程，等到線程池的線程數等於線程池基本大小時就不再創建。如果調用了線程池的prestartAllCoreThreads()方法，線程池會提前創建並啟動所有基本線程。
maximumPoolSize（線程池最大數量）：線程池允許創建的最大線程數。如果隊列滿了，並且已創建的線程數小於最大線程數，則線程池會再創建新的線程執行任務。值得注意的是，如果使用了無界的任務隊列這個參數就沒什麼效果。
keepAliveTime（線程活動保持時間）：線程池的工作線程空閑後，保持存活的時間。所以，如果任務很多，並且每個任務執行的時間比較短，可以調大時間，提高線程的利用率。
TimeUnit（線程活動保持時間的單位）：可選的單位有天（DAYS）、小時（HOURS）、分鍾（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和納秒（NANOSECONDS，千分之一微秒）。
runnableTaskQueue（任務隊列）：用於保存等待執行的任務的阻塞隊列。可以選擇以下幾個阻塞隊列。
- ArrayBlockingQueue：是一個基於數組結構的有界阻塞隊列，此隊列按FIFO（先進先出）原則對元素進行排序。
LinkedBlockingQueue：一個基於鏈表結構的阻塞隊列，此隊列按FIFO排序元素，吞吐量通常要高於ArrayBlockingQueue。靜態工廠方法Executors.newFixedThreadPool()使用了這個隊列。
SynchronousQueue：一個不存儲元素的阻塞隊列。每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處於阻塞狀態，吞吐量通常要高於LinkedBlockingQueue，靜態工廠方法Executors.newCachedThreadPool使用了這個隊列。
PriorityBlockingQueue：一個具有優先順序的無界阻塞隊列。
線程的狀態
在HotSpot VM線程模型中，Java線程被一對一映射到本地系統線程，Java線程啟動時會創建一個本地系統線程；當Java線程終止時，這個本地系統線程也會被回收。操作系統調度所有線程並把它們分配給可用的CPU。

thread運行周期中，有以下6種狀態，在 java.lang.Thread.State 中有詳細定義和說明：

// Thread類
public enum State {
/**
* 剛創建尚未運行
*/
NEW,

/**
* 可運行狀態，該狀態表示正在JVM中處於運行狀態，不過有可能是在等待其他資源，比如CPU時間片，IO等待
*/
RUNNABLE,

/**
* 阻塞狀態表示等待monitor鎖（阻塞在等待monitor鎖或者在調用Object.wait方法後重新進入synchronized塊時阻塞）
*/
BLOCKED,

/**
* 等待狀態，發生在調用Object.wait、Thread.join (with no timeout)、LockSupport.park
* 表示當前線程在等待另一個線程執行某種動作，比如Object.notify()、Object.notifyAll()，Thread.join表示等待線程執行完成
*/
WAITING,

/**
* 超時等待，發生在調用Thread.sleep、Object.wait、Thread.join (in timeout)、LockSupport.parkNanos、LockSupport.parkUntil
*/
TIMED_WAITING,

/**
*線程已執行完成，終止狀態
*/
TERMINATED;
}
線程池操作
向線程池提交任務，可以使用兩個方法向線程池提交任務，分別為execute()和submit()方法。execute()方法用於提交不需要返回值的任務，所以無法判斷任務是否被線程池執行成功。通過以下代碼可知execute()方法輸入的任務是一個Runnable類的實例。

threadsPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});
submit()方法用於提交需要返回值的任務。線程池會返回一個future類型的對象，通過這個future對象可以判斷任務是否執行成功，通過future的get()方法來獲取返回值，future的get()方法會阻塞當前線程直到任務完成，而使用get（long timeout，TimeUnit unit）方法則會阻塞當前線程一段時間後立即返回，這時候有可能任務還沒有執行完。

Future<Object> future = executor.submit(harReturnValuetask);
try {
Object s = future.get();
} catch (InterruptedException e) {
// 處理中斷異常
} catch (ExecutionException e) {
// 處理無法執行任務異常
} finally {
// 關閉線程池
executor.shutdown();
}
合理配置線程池
要想合理配置線程池，必須先分析任務的特點，可以從以下幾個角度分析：

任務的性質：CPU密集型任務、IO密集型任務和混合型任務。
任務的優先順序：高、中和低。
任務的執行時間：長、中和短。
任務的依賴性：是否依賴其他系統資源，如資料庫連接。
性質不同的任務可以用不同規模的線程池分開處理。CPU密集型任務應配置盡可能少的線程，如配置Ncpu+1個線程的線程池。由於IO密集型任務線程並不是一直在執行任務，則應配置多一點線程，如2*Ncpu。混合型的任務，如果可以拆分，將其拆分成一個CPU密集型任務和一個IO密集型任務，只要這兩個任務執行的時間相差不是太大，那麼分解後執行的吞吐量將高於串列執行的吞吐量。如果這兩個任務執行時間相差太大，則沒必要進行分解。可以通過Runtime.getRuntime().availableProcessors()方法獲得當前設備的CPU個數。

優先順序不同的任務可以使用優先順序隊列PriorityBlockingQueue來處理。它可以讓優先順序高的任務先執行。執行時間不同的任務可以交給不同規模的線程池來處理，或者可以使用優先順序隊列，讓執行時間短的任務先執行。依賴資料庫連接池的任務，因為線程提交SQL後需要等待資料庫返回結果，等待的時間越長，則CPU空閑時間就越長，那麼線程數應該設置得越大，這樣才能更好地利用CPU。

線程池中線程數量未達到coreSize時，這些線程處於什麼狀態？

這些線程處於RUNNING或者WAITING，RUNNING表示線程處於運行當中，WAITING表示線程阻塞等待在阻塞隊列上。當一個task submit給線程池時，如果當前線程池線程數量還未達到coreSize時，會創建線程執行task，否則將任務提交給阻塞隊列，然後觸發線程執行。（從submit內部調用的代碼也可以看出來）

ScheledThreadPoolExecutor

ScheledThreadPoolExecutor繼承自ThreadPoolExecutor。它主要用來在給定的延遲之後運行任務，或者定期執行任務。
ScheledThreadPoolExecutor的功能與Timer類似，但
ScheledThreadPoolExecutor功能更強大、更靈活。Timer對應的是單個後台線程，而
ScheledThreadPoolExecutor可以在構造函數中指定多個對應的後台線程數。

ScheledThreadPoolExecutor繼承自ThreadPoolExecutor，
ScheledThreadPoolExecutor和ThreadPoolExecutor的區別是，ThreadPoolExecutor獲取任務時是從BlockingQueue中獲取的，而
ScheledThreadPoolExecutor是從DelayedWorkQueue中獲取的（注意，DelayedWorkQueue是BlockingQueue的實現類）。

ScheledThreadPoolExecutor把待調度的任務（ScheledFutureTask）放到一個DelayQueue中，其中ScheledFutureTask主要包含3個成員變數：

sequenceNumber：任務被添加到ScheledThreadPoolExecutor中的序號；
time：任務將要被執行的具體時間；
period：任務執行的間隔周期。

ScheledThreadPoolExecutor會把待執行的任務放到工作隊列DelayQueue中，DelayQueue封裝了一個PriorityQueue，PriorityQueue會對隊列中的ScheledFutureTask進行排序，具體的排序比較演算法實現如下：

ScheledFutureTask在DelayQueue中被保存在一個PriorityQueue（基於數組實現的優先隊列，類似於堆排序中的優先隊列）中，在往數組中添加/移除元素時，會調用siftDown/siftUp來進行元素的重排序，保證元素的優先順序順序。

static class DelayedWorkQueue extends AbstractQueue<Runnable>
implements BlockingQueue<Runnable> {

private static final int INITIAL_CAPACITY = 16;
private RunnableScheledFuture<?>[] queue =
new RunnableScheledFuture<?>[INITIAL_CAPACITY];
private final ReentrantLock lock = new ReentrantLock();
private int size = 0;

private Thread leader = null;
private final Condition available = lock.newCondition();
}
從DelayQueue獲取任務的主要邏輯就在take()方法中，首先獲取lock，然後獲取queue[0]，如果為null則await等待任務的來臨，如果非null查看任務是否到期，是的話就執行該任務，否則再次await等待。這里有一個leader變數，用來表示當前進行awaitNanos等待的線程，如果leader非null，表示已經有其他線程在進行awaitNanos等待，自己await等待，否則自己進行awaitNanos等待。

// DelayedWorkQueue
public RunnableScheledFuture<?> take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
RunnableScheledFuture<?> first = queue[0];
if (first == null)
available.await();
else {
long delay = first.getDelay(NANOSECONDS);
if (delay <= 0)
return finishPoll(first);
first = null; // don't retain ref while waiting
if (leader != null)
available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
available.awaitNanos(delay);
} finally {
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
if (leader == null && queue[0] != null)
available.signal();
lock.unlock();
}
}
獲取到任務之後，就會執行task的run()方法了，即ScheledFutureTask.run()：

public void run() {
boolean periodic = isPeriodic();
if (!canRunInCurrentRunState(periodic))
cancel(false);
else if (!periodic)
ScheledFutureTask.super.run();
else if (ScheledFutureTask.super.runAndReset()) {
setNextRunTime();
reExecutePeriodic(outerTask);
}
}
推薦閱讀：
JMM Java內存模型
happens-before那些事兒
為什麼說LockSupport是Java並發的基石？
責任鏈的2種實現方式，你更pick哪一種
2閱讀

❺ 資料庫連接池的工作機制是什麼

資料庫連接池在初始化時將創建一定數量的資料庫連接放到連接池中，這些資料庫連接的數量是由最小資料庫連接數來設定的。對資料庫連接的管理能顯著影響到整個應用程序的伸縮性和健壯性，影響到程序的性能指標。

資料庫連接池正是針對這個問題提出來的。資料庫連接池負責分配、管理和釋放資料庫連接，它允許應用程序重復使用一個現有的資料庫連接，而再不是重新建立一個，釋放空閑時間超過最大空閑時間的資料庫連接來避免因為沒有釋放資料庫連接而引起的資料庫連接遺漏。這項技術能明顯提高對資料庫操作的性能。

(5)資料庫連接池什麼時候會創建線程擴展閱讀：

資料庫連接池在初始化時將創建一定數量的資料庫連接放到連接池中，這些資料庫連接的數量是由最小資料庫連接數制約。無論這些資料庫連接是否被使用，連接池都將一直保證至少擁有這么多的連接數量。連接池的最大數據庫連接數量限定了這個連接池能佔有的最大連接數，當應用程序向連接池請求的連接數超過最大連接數量時，這些請求將被加入到等待隊列中。

❻ Java線程池

java常用的線程池有三種：
1.
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads)創建一個可重用固定線程數的線程池，以共享的無界隊列方式來運行這些線程。在任意點，在大多數 nThreads 線程會處於處理任務的活動狀態。如果在所有線程處於活動狀態時提交附加任務，則在有可用線程之前，附加任務將在隊列中等待。如果在關閉前的執行期間由於失敗而導致任何線程終止，那麼一個新線程將代替它執行後續的任務（如果需要）。在某個線程被顯式地關閉之前，池中的線程將一直存在。

參數：
nThreads - 池中的線程數
返回：
新創建的線程池
拋出：
IllegalArgumentException - 如果 nThreads <= 0

2.
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor()創建一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個線程，那麼如果需要，一個新線程將代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個線程是活動的。與其他等效的 newFixedThreadPool(1) 不同，可保證無需重新配置此方法所返回的執行程序即可使用其他的線程。

返回：
新創建的單線程 Executor

3.
newCachedThreadPool
public static ExecutorService newCachedThreadPool()創建一個可根據需要創建新線程的線程池，但是在以前構造的線程可用時將重用它們。對於執行很多短期非同步任務的程序而言，這些線程池通常可提高程序性能。調用 execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鍾未被使用的線程。因此，長時間保持空閑的線程池不會使用任何資源。注意，可以使用 ThreadPoolExecutor 構造方法創建具有類似屬性但細節不同（例如超時參數）的線程池。

返回：
新創建的線程池

❼ oracle資料庫連接池怎麼配置

連接池是創建和管理多個連接的一種技術，這些連接可被需要使用它們的任何線程使用。連接池技術基於下述事實：對於大多數應用程序，當它們正在處理通常需要數毫秒完成的事務時，僅需要能夠訪問JDBC連接的1個線程。未處理事務時，連接處於閑置狀態。使用連接池，允許其他線程使用閑置連接來執行有用的任務。事實上，當某一線程需要用JDBC在MySQL或其他資料庫上執行操作時，需要用到由連接池提供的連接。使用連接完成線程後，線程會將連接返回給連接池，以便該連接能夠被其他需要使用連接的線程使用。從連接池「借出」連接時，該連接僅供請求它的線程使用。從編程觀點看，其效果等同於每次需要JDBC連接時調用DriverManager.getConnection()，但是，採用連接池技術，可通過使用新的或已有的連接結束線程。連接池技術能顯著增加Java應用程序的性能，同時還能降低資源使用率。
http://blog.csdn.net/xilangyuyun/article/details/52800380