連線池相關概念：

對於共享資源，有一個很著名的設計模式：資源池（Resource Pool）。該模式正是為了解決資源的頻繁分配﹑釋放所造成的問題。為解決我們的問題，可以採用資料庫連線池技術。資料庫連線池的基本思想就是為資料庫連線建立一個“緩衝池”。預先在緩衝池中放入一定數量的連線，當需要建立資料庫連線時，只需從“緩衝池”中取出一個，使用完畢之後再放回去。我們可以通過設定連線池最大連線數來防止系統無盡的與資料庫連線。更為重要的是我們可以通過連線池的管理機制監視資料庫的連線的數量﹑使用情況，為系統開發﹑測試及效能調整提供依據。

為什麼使用連線池

連線，是我們的程式語言與資料庫互動的一種方式。我們經常會聽到這麼一句話“資料庫連線很昂貴“。

有人接受這種說法，卻不知道它的真正含義。因此，下面通過例項解釋它究竟是什麼。

下面是MySQL資料庫建立連線的的一段程式碼：

String connUrl ="jdbc:mysql://your.database.domain/yourDBname";  
Class.forName("com.mysql.jdbc.Driver");  
Connection con =DriverManager.getConnection (connUrl);

當我們建立了一個Connection物件，它在內部都執行了什麼：

1.“DriverManager”檢查並註冊驅動程式；

2.“com.mysql.jdbc.Driver”就是我們註冊了的驅動程式，它會在驅動程式類中呼叫“connect(url…)”方法。

3.com.mysql.jdbc.Driver的connect方法根據我們請求的“connUrl”，建立一個“Socket連線”，連線到IP為“your.database.domain”，預設埠3306的資料庫。

4.建立的Socket連線將被用來查詢我們指定的資料庫，並最終讓程式返回得到一個結果。

簡單的獲取一個連線，系統卻要在背後做很多消耗資源的事情，大多時候，建立連線的時間比執行sql語句的時間還要長。

傳統的獲取連線方式如下圖所示：

使用者每次請求都需要向資料庫獲得連結，而資料庫建立連線通常需要消耗相對較大的資源，建立時間也較長。假設網站一天10萬訪問量，資料庫伺服器就需要建立10萬次連線，極大的浪費資料庫的資源，並且極易造成資料庫伺服器記憶體溢位、拓機。

採用連線池技術後的過程如下：

資料庫連線是一種關鍵的有限的昂貴的資源，這一點在多使用者的網頁應用程式中體現的尤為突出。對資料庫連線的管理能顯著影響到整個應用程式的伸縮性和健壯性，影響到程式的效能指標。資料庫連線池負責分配，管理和釋放資料庫連線，它允許應用程式重複使用一個現有的資料庫連線，而不是重新建立一個。

需要注意的問題

1、併發問題

為了使連線管理服務具有最大的通用性，必須考慮多執行緒環境，即併發問題。這個問題相對比較好解決，因為各個語言自身提供了對併發管理的支援像java,c#等等，使用synchronized(java)、lock(C#)關鍵字即可確保執行緒是同步的。

2、事務處理

我們知道，事務具有原子性，此時要求對資料庫的操作符合“ALL-OR-NOTHING”原則，即對於一組SQL語句要麼全做，要麼全不做。

我們知道當２個執行緒公用一個連線Connection物件，而且各自都有自己的事務要處理時候，對於連線池是一個很頭疼的問題，因為即使Connection類提供了相應的事務支援，可是我們仍然不能確定那個資料庫操作是對應那個事務的，這是由於我們有２個執行緒都在進行事務操作而引起的。為此我們可以使用每一個事務獨佔一個連線來實現，雖然這種方法有點浪費連線池資源但是可以大大降低事務管理的複雜性。

３、連線池的分配與釋放

連線池的分配與釋放，對系統的效能有很大的影響。合理的分配與釋放，可以提高連線的複用度，從而降低建立新連線的開銷，同時還可以加快使用者的訪問速度。

對於連線的管理可使用一個List。即把已經建立的連線都放入List中去統一管理。每當使用者請求一個連線時，系統檢查這個List中有沒有可以分配的連線。如果有就把那個最合適的連線分配給他（如何能找到最合適的連線文章將在關鍵議題中指出）；如果沒有就丟擲一個異常給使用者，List中連線是否可以被分配由一個執行緒來專門管理。

４、連線池的配置與維護

連線池中到底應該放置多少連線，才能使系統的效能最佳？系統可採取設定最小連線數（minConnection）和最大連線數（maxConnection）等引數來控制連線池中的連線。比方說，最小連線數是系統啟動時連線池所建立的連線數。如果建立過多，則系統啟動就慢，但建立後系統的響應速度會很快；如果建立過少，則系統啟動的很快，響應起來卻慢。這樣，可以在開發時，設定較小的最小連線數，開發起來會快，而在系統實際使用時設定較大的，因為這樣對訪問客戶來說速度會快些。最大連線數是連線池中允許連線的最大數目，具體設定多少，要看系統的訪問量，可通過軟體需求上得到。

如何確保連線池中的最小連線數呢？有動態和靜態兩種策略。動態即每隔一定時間就對連線池進行檢測，如果發現連線數量小於最小連線數，則補充相應數量的新連線，以保證連線池的正常運轉。靜態是發現空閒連線不夠時再去檢查。

我的理解是相當於 一種 依快取的方式，減少 直接與資源庫的互動，節約時間與資源的建立從而提高效率；

下面為實現 連線池的具體程式碼（mysql為例）：

package com.java.auto.pool;

import java.sql.Connection;

/**
 * 定義 池pool具有的規則
 * @author zhangqingzhou
 *
 */
public interface Pool {
	/**
	 * 獲取 最初初始化的 連線數
	 * @return
	 */
	public int getInitialConnections() ;
	
	/**
	 * 設定 初始化連線數
	 * @param initialConnections
	 */
	public void setInitialConnections(int initialConnections);
	/**
	 * 每次增長值
	 * @return
	 */
	public int getIncrementalConnections() ;
	/**
	 * 設定 每次增長值
	 * @param incrementalConnections
	 */
	 public void setIncrementalConnections(int incrementalConnections);
	 
	 /**
	  * 獲取最大連線數
	  * @return
	  */
	 public int getMaxConnections();

	 /**
	  * 設定最大連線數
	  *
	  */
	 public void setMaxConnections(int maxConnections);
	 
	 /**
	  * 初始化池
	  */
	 public  void initPool();
	 
	 /**
	  * 獲取連線
	  * @return
	  */
	 public  Connection getConnection();
	 
	 /**
	  * 釋放(返還)連線到 池子
	  * @param conn
	  */
	 public void returnConnection(Connection conn);
	 
	 /**
	  * 重新整理 池子
	  * 相當於重啟
	  */
	 public  void refreshConnections();
	 
	 /**
	  * 關閉連線池
	  */
	 public  void closeConnectionPool() ;
}

package com.java.auto.pool;

import java.sql.Connection;

/**
 * 記錄每個已經建立連線的狀態  是否忙碌
 * 便於 獲取非忙碌的 connect
 * @author zhangqingzhou
 *
 */
public class PooledConnection {
	 Connection connection = null; // 資料庫連線
	// 此連線是否正在使用的標誌，預設沒有正在使用
     boolean busy = false; 
     // 建構函式，根據一個 Connection 構告一個 PooledConnection 物件
     public PooledConnection(Connection connection) {
         this.connection = connection;
     }

     // 返回此物件中的連線
     public Connection getConnection() {
         return connection;
     }

     // 設定此物件的，連線
     public void setConnection(Connection connection) {
         this.connection = connection;
     }

     // 獲得物件連線是否忙
     public boolean isBusy() {
         return busy;
     }

     // 設定物件的連線正在忙
     public void setBusy(boolean busy) {
         this.busy = busy;
     }


 }

package com.java.auto.pool;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;
// 具體實現類
public class ConnectionPool {

	private String jdbcDriver = ""; // 資料庫驅動
    private String dbUrl = ""; // 資料 URL
    private String dbUsername = ""; // 資料庫使用者名稱
    private String dbPassword = ""; // 資料庫使用者密碼
    private String testTable = ""; // 測試連線是否可用的測試表名，預設沒有測試表
    private int initialConnections = 10; // 連線池的初始大小
    private int incrementalConnections = 5; // 連線池自動增加的大小
    private int maxConnections = 50; // 連線池最大的大小
    private Vector connections = null; // 存放連線池中資料庫連線的向量 , 初始時為 null
// 它中存放的物件為 PooledConnection 型
    
    public ConnectionPool(String jdbcDriver, String dbUrl, String dbUsername,
            String dbPassword) {

			this.jdbcDriver = jdbcDriver;
			this.dbUrl = dbUrl;
			this.dbUsername = dbUsername;
			this.dbPassword = dbPassword;
}
    public int getInitialConnections() {
        return this.initialConnections;
    }

   
    public void setInitialConnections(int initialConnections) {
        this.initialConnections = initialConnections;
    }

   
    public int getIncrementalConnections() {
        return this.incrementalConnections;
    }

   
    public void setIncrementalConnections(int incrementalConnections) {
        this.incrementalConnections = incrementalConnections;
    }

   
    public int getMaxConnections() {
        return this.maxConnections;
    }

   
    public void setMaxConnections(int maxConnections) {
        this.maxConnections = maxConnections;
    }

   
    public String getTestTable() {
        return this.testTable;
    }

   
    public void setTestTable(String testTable) {
        this.testTable = testTable;
    }
    
    public synchronized void createPool() throws Exception {
        // 確保連線池沒有建立
        // 假如連線池己經建立了，儲存連線的向量 connections 不會為空
        if (connections != null) {
            return; // 假如己經建立，則返回
        }
        // 例項化 JDBC Driver 中指定的驅動類例項
        Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
        DriverManager.registerDriver(driver); // 註冊 JDBC 驅動程式
        // 建立儲存連線的向量 , 初始時有 0 個元素
        connections = new Vector();
        // 根據 initialConnections 中設定的值，建立連線。
        createConnections(this.initialConnections);
        System.out.println(" 資料庫連線池建立成功！ ");
    }

   
    private void createConnections(int numConnections) throws SQLException {
        // 迴圈建立指定數目的資料庫連線
        for (int x = 0; x < numConnections; x++) {
            // 是否連線池中的資料庫連線的數量己經達到最大？最大值由類成員 maxConnections
            // 指出，假如 maxConnections 為 0 或負數，表示連線數量沒有限制。
            // 假如連線數己經達到最大，即退出。
            if (this.maxConnections > 0 &&
                this.connections.size() >= this.maxConnections) {
                break;
            }
            //add a new PooledConnection object to connections vector
            // 增加一個連線到連線池中（向量 connections 中）
            try {
                connections.addElement(new PooledConnection(newConnection()));
            } catch (SQLException e) {
                System.out.println(" 建立資料庫連線失敗！ " + e.getMessage());
                throw new SQLException();
            }
            System.out.println(" 資料庫連線己建立 ......");
        }
    }

   
    private Connection newConnection() throws SQLException {
        // 建立一個數據庫連線
        Connection conn = DriverManager.getConnection(dbUrl, dbUsername,
                dbPassword);
        // 假如這是第一次建立資料庫連線，即檢查資料庫，獲得此資料庫答應支援的
        // 最大客戶連線數目
        //connections.size()==0 表示目前沒有連線己被建立
        if (connections.size() == 0) {
            DatabaseMetaData metaData = conn.getMetaData();
            int driverMaxConnections = metaData.getMaxConnections();
            // 資料庫返回的 driverMaxConnections 若為 0 ，表示此資料庫沒有最大
            // 連線限制，或資料庫的最大連線限制不知道
            //driverMaxConnections 為返回的一個整數，表示此資料庫答應客戶連線的數目
            // 假如連線池中設定的最大連線數量大於資料庫答應的連線數目 , 則置連線池的最大
            // 連線數目為資料庫答應的最大數目
            if (driverMaxConnections > 0 &&
                this.maxConnections > driverMaxConnections) {
                this.maxConnections = driverMaxConnections;
            }
        }
        return conn; // 返回建立的新的資料庫連線
    }

   

    public synchronized Connection getConnection() throws SQLException {
        // 確保連線池己被建立
        if (connections == null) {
            return null; // 連線池還沒建立，則返回 null
        }
        Connection conn = getFreeConnection(); // 獲得一個可用的資料庫連線
        // 假如目前沒有可以使用的連線，即所有的連線都在使用中
        while (conn == null) {
            // 等一會再試
            wait(250);
            conn = getFreeConnection(); // 重新再試，直到獲得可用的連線，假如
            //getFreeConnection() 返回的為 null
            // 則表明建立一批連線後也不可獲得可用連線
        }
        return conn; // 返回獲得的可用的連線
    }

   
    private Connection getFreeConnection() throws SQLException {
        // 從連線池中獲得一個可用的資料庫連線
        Connection conn = findFreeConnection();
        if (conn == null) {
            // 假如目前連線池中沒有可用的連線
            // 建立一些連線
            createConnections(incrementalConnections);
            // 重新從池中查詢是否有可用連線
            conn = findFreeConnection();
            if (conn == null) {
                // 假如建立連線後仍獲得不到可用的連線，則返回 null
                return null;
            }
        }
        return conn;
    }

   
    private Connection findFreeConnection() throws SQLException {
        Connection conn = null;
        PooledConnection pConn = null;
        // 獲得連線池向量中所有的物件
        Enumeration enumerate = connections.elements();
        // 遍歷所有的物件，看是否有可用的連線
        while (enumerate.hasMoreElements()) {
            pConn = (PooledConnection) enumerate.nextElement();
            if (!pConn.isBusy()) {
                // 假如此物件不忙，則獲得它的資料庫連線並把它設為忙
                conn = pConn.getConnection();
                pConn.setBusy(true);
                // 測試此連線是否可用
                if (!testConnection(conn)) {
                    // 假如此連線不可再用了，則建立一個新的連線，
                    // 並替換此不可用的連線物件，假如建立失敗，返回 null
                    try {
                        conn = newConnection();
                    } catch (SQLException e) {
                        System.out.println(" 建立資料庫連線失敗！ " + e.getMessage());
                        return null;
                    }
                    pConn.setConnection(conn);
                }
                break; // 己經找到一個可用的連線，退出
            }
        }
        return conn; // 返回找到到的可用連線
    }

   
    private boolean testConnection(Connection conn) {
        try {
            // 判定測試表是否存在
            if (testTable.equals("")) {
                // 假如測試表為空，試著使用此連線的 setAutoCommit() 方法
                // 來判定連線否可用（此方法只在部分資料庫可用，假如不可用 ,
                // 丟擲異常）。注重：使用測試表的方法更可靠
                conn.setAutoCommit(true);
            } else { // 有測試表的時候使用測試表測試
                //check if this connection is valid
                Statement stmt = conn.createStatement();
                stmt.execute("select count(*) from " + testTable);
            }
        } catch (SQLException e) {
            // 上面丟擲異常，此連線己不可用，關閉它，並返回 false;
            closeConnection(conn);
            return false;
        }
        // 連線可用，返回 true
        return true;
    }

   
    public void returnConnection(Connection conn) {
        // 確保連線池存在，假如連線沒有建立（不存在），直接返回
        if (connections == null) {
            System.out.println(" 連線池不存在，無法返回此連線到連線池中 !");
            return;
        }
        PooledConnection pConn = null;
        Enumeration enumerate = connections.elements();
        // 遍歷連線池中的所有連線，找到這個要返回的連線物件
        while (enumerate.hasMoreElements()) {
            pConn = (PooledConnection) enumerate.nextElement();
            // 先找到連線池中的要返回的連線物件
            if (conn == pConn.getConnection()) {
                // 找到了 , 設定此連線為空閒狀態
                pConn.setBusy(false);
                break;
            }
        }
    }

   

    public synchronized void refreshConnections() throws SQLException {
        // 確保連線池己創新存在
        if (connections == null) {
            System.out.println(" 連線池不存在，無法重新整理 !");
            return;
        }
        PooledConnection pConn = null;
        Enumeration enumerate = connections.elements();
        while (enumerate.hasMoreElements()) {
            // 獲得一個連線物件
            pConn = (PooledConnection) enumerate.nextElement();
            // 假如物件忙則等 5 秒 ,5 秒後直接重新整理
            if (pConn.isBusy()) {
                wait(5000); // 等 5 秒
            }
            // 關閉此連線，用一個新的連線代替它。
            closeConnection(pConn.getConnection());
            pConn.setConnection(newConnection());
            pConn.setBusy(false);
        }
    }

   
    public synchronized void closeConnectionPool() throws SQLException {
        // 確保連線池存在，假如不存在，返回
        if (connections == null) {
            System.out.println(" 連線池不存在，無法關閉 !");
            return;
        }
        PooledConnection pConn = null;
        Enumeration enumerate = connections.elements();
        while (enumerate.hasMoreElements()) {
            pConn = (PooledConnection) enumerate.nextElement();
            // 假如忙，等 5 秒
            if (pConn.isBusy()) {
                wait(5000); // 等 5 秒
            }
            //5 秒後直接關閉它
            closeConnection(pConn.getConnection());
            // 從連線池向量中刪除它
            connections.removeElement(pConn);
        }
        // 置連線池為空
        connections = null;
    }

   
    private void closeConnection(Connection conn) {
        try {
            conn.close();
        } catch (SQLException e) {
            System.out.println(" 關閉資料庫連接出錯： " + e.getMessage());
        }
    }

   
    private void wait(int mSeconds) {
        try {
            Thread.sleep(mSeconds);
        } catch (InterruptedException e) {
        }
    }

   

}

package com.java.auto.pool;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * 連線池 工具類
 * @author zhangqingzhou
 *
 */
public class PoolUtil implements Pool{
	
	/**
	 * 此處可以設定成 讀取 配置檔案的方式
	 */
	private static String jdbcDriver = "com.mysql.jdbc.Driver"; // 資料庫驅動
    private static String dbUrl = "jdbc:mysql://localhost:3308/test"; // 資料 URL
    private static String dbUsername = " "; // 資料庫使用者名稱
    private static String dbPassword = "66666"; // 資料庫使用者密碼

	private static ConnectionPool connPool = null;
	
	// 設定成單例模式 防止 多次例項化連線池
	 private static PoolUtil instance = new PoolUtil();
	 private PoolUtil(){};
	 public static PoolUtil getInstance(){
		 
		 return instance;
	 }
	
	static{
		
		connPool = new ConnectionPool(jdbcDriver, dbUrl , dbUsername, dbPassword);
	                
	}
	
	@Override
	public int getInitialConnections() {
		
		return connPool.getInitialConnections();
	}

	@Override
	public void setInitialConnections(int initialConnections) {
		
		connPool.setInitialConnections(initialConnections);
	}

	@Override
	public int getIncrementalConnections() {
		
		return connPool.getIncrementalConnections();
	}

	@Override
	public void setIncrementalConnections(int incrementalConnections) {
		
		connPool.setIncrementalConnections(incrementalConnections);
	}

	@Override
	public int getMaxConnections() {
		
		return connPool.getMaxConnections();
	}

	@Override
	public void setMaxConnections(int maxConnections) {
		
		connPool.setMaxConnections(maxConnections);
	}

	@Override
	public void initPool() {
		try {
			connPool.createPool();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}

	@Override
	public Connection getConnection() {
		
		Connection conn = null;
		try {
			conn = connPool.getConnection();
		} catch (SQLException e) {
			
			e.printStackTrace();
		}
		return conn;
	}

	@Override
	public void returnConnection(Connection conn) {
		
		connPool.returnConnection(conn);
	}

	@Override
	public void refreshConnections() {
		
		try {
			connPool.refreshConnections();
		} catch (SQLException e) {
			
			e.printStackTrace();
		}
	}

	@Override
	public void closeConnectionPool() {
		
		try {
			connPool.closeConnectionPool();
		} catch (SQLException e) {
			
			e.printStackTrace();
		}
	}
	
}

package com.java.auto.pool;

import java.sql.Connection;

/**
 * 測試類
 * @author zhangqingzhou
 *
 */
public class Test {

	public static void main(String[] args) {
		PoolUtil pool = PoolUtil.getInstance();
		pool.initPool();
		Connection connection = pool.getConnection();
		System.out.println("connection:"+connection);
		//pool.returnConnection(connection);
	}
}

 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線己建立 ......
 資料庫連線池建立成功！ 
connection:[email protected]

不足之處，請指正！

相關資料：

http://blog.csdn.net/fangquan1980/article/details/52429903

http://www.open-open.com/lib/view/open1410875608164.html