1.jdbc連線資料庫，就這樣子
Class.forName("com.mysql.jdbc.Driver");
java.sql.Connection conn = DriverManager.getConnection(jdbcUrl);
2.通過傳入jdbc url用Drivermanager.getConnection(jdbcurl)連線資料庫，
注意：一次Drivermanager.getConnection(jdbcurl)獲得只是一個connection，並不能滿足高併發情況。因為connection不是執行緒安全的，一個connection對應的是一個事物。
3.所以資料庫連線池，是多次Drivermanager.getConnection(jdbcurl)，獲取多個connection放入hashmap中。
4.每次獲得connection都需要浪費cpu資源和記憶體資源，是很浪費資源的。所以誕生了資料庫連線池。
5.資料庫連線池部分原始碼：
注意pool.getConnection()，都是先從threadlocal裡面拿的，如果threadlocal裡面有，則用，保證執行緒裡的多個dao操作，用的是同一個connection，以保證事務。
如果新執行緒，則將新的connection放在threadlocal裡，再get給到執行緒。
著重看以下幾個方法，說明資料庫連線池，是將connection放進threadlocal裡的，以保證每個執行緒從連線池中獲得的都是執行緒自己的connection。
- // 將執行緒和連線繫結，保證事務能統一執行
- 成員變數 private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
// 獲得當前連線
public Connection getCurrentConnecton(){
// 預設執行緒裡面取
Connection conn = threadLocal.get();
if(!isValid(conn)){
conn = getConnection();
}
return conn;
}
// 獲得連線
public synchronized Connection getConnection() {
Connection conn = null;
try {
// 判斷是否超過最大連線數限制
if(contActive < this.dbBean.getMaxActiveConnections()){
if (freeConnection.size() > 0) {
conn = freeConnection.get(0);
if (conn != null) {
threadLocal.set(conn);
}
freeConnection.remove(0);
} else {
conn = newConnection();
}
}else{
// 繼續獲得連線,直到從新獲得連線
wait(this.dbBean.getConnTimeOut());
conn = getConnection();
}
if (isValid(conn)) {
activeConnection.add(conn);
contActive ++;
}
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
return conn;
}public synchronized void releaseConn(Connection conn) throws SQLException {
if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) {
freeConnection.add(conn);
activeConnection.remove(conn);
contActive --;
threadLocal.remove();
// 喚醒所有正待等待的執行緒，去搶連線
notifyAll();
}
} 然後再著重理解此段話
首先,LZ是概念上的錯誤.什麼是執行緒池,什麼是ThreadLocal??? 執行緒池,為避免不必要的建立,銷燬connection而存在的,其中包括活動,等待,最小等屬性,cop3,proxy連線池都可以配置這些玩意; 至於為什麼要用ThreadLocal呢?這個和連線池無關,我認為更多的是和程式本身相關,為了更清楚的說明,我舉個例子 servlet中獲取一個連線.首先,servlet是執行緒安全的嗎? class MyServlet extends HttpServlet{ private Connection conn; } ok,遺憾的告訴你,這個conn並不是安全的,所有請求這個servlet的連線,使用的都是一個Connection,這個就是致命的了.多個人使用同一個連線,算上延遲啥的,天知道資料會成什麼樣. 因此我們要保證Connection對每個請求都是唯一的.這個時候就可以用到ThreadLocal了,保證每個執行緒都有自己的連線. 改為 private ThreadLocal<Connection> ct = new ThreadLocal<Connnection>(); 然後從連線池獲取Connection,set到ct中,再get就行了,至於得到的是哪個Connection就是連線池的問題了,你也管不到.
Hibernate的資料庫連線池就是將connection放進threadlocal實現的！！！
Hibernate的資料庫連線池就是將connection放進threadlocal實現的！！！
Hibernate的資料庫連線池就是將connection放進threadlocal實現的！！！
public class ConnectionPool implements IConnectionPool { // 連線池配置屬性 private DBbean dbBean; private boolean isActive = false; // 連線池活動狀態 private int contActive = 0;// 記錄建立的總的連線數 // 空閒連線 private List<Connection> freeConnection = new Vector<Connection>(); // 活動連線 private List<Connection> activeConnection = new Vector<Connection>();
- // 將執行緒和連線繫結，保證事務能統一執行
- private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
public ConnectionPool(DBbean dbBean) { super(); this.dbBean = dbBean; init(); cheackPool(); } // 初始化 public void init() { try { Class.forName(dbBean.getDriverName()); for (int i = 0; i < dbBean.getInitConnections(); i++) { Connection conn; conn = newConnection(); // 初始化最小連線數 if (conn != null) { freeConnection.add(conn); contActive++; } } isActive = true; } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } } // 獲得當前連線 public Connection getCurrentConnecton(){ // 預設執行緒裡面取 Connection conn = threadLocal.get(); if(!isValid(conn)){ conn = getConnection(); } return conn; } // 獲得連線 public synchronized Connection getConnection() { Connection conn = null; try { // 判斷是否超過最大連線數限制 if(contActive < this.dbBean.getMaxActiveConnections()){ if (freeConnection.size() > 0) { conn = freeConnection.get(0); if (conn != null) { threadLocal.set(conn); } freeConnection.remove(0); } else { conn = newConnection(); } }else{ // 繼續獲得連線,直到從新獲得連線 wait(this.dbBean.getConnTimeOut()); conn = getConnection(); } if (isValid(conn)) { activeConnection.add(conn); contActive ++; } } catch (SQLException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } return conn; } // 獲得新連線 private synchronized Connection newConnection() throws ClassNotFoundException, SQLException { Connection conn = null; if (dbBean != null) { Class.forName(dbBean.getDriverName()); conn = DriverManager.getConnection(dbBean.getUrl(), dbBean.getUserName(), dbBean.getPassword()); } return conn; } // 釋放連線 public synchronized void releaseConn(Connection conn) throws SQLException { if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) { freeConnection.add(conn); activeConnection.remove(conn); contActive --; threadLocal.remove(); // 喚醒所有正待等待的執行緒，去搶連線 notifyAll(); } } // 判斷連線是否可用 private boolean isValid(Connection conn) { try { if (conn == null || conn.isClosed()) { return false; } } catch (SQLException e) { e.printStackTrace(); } return true; } // 銷燬連線池 public synchronized void destroy() { for (Connection conn : freeConnection) { try { if (isValid(conn)) { conn.close(); } } catch (SQLException e) { e.printStackTrace(); } } for (Connection conn : activeConnection) { try { if (isValid(conn)) { conn.close(); } } catch (SQLException e) { e.printStackTrace(); } } isActive = false; contActive = 0; } // 連線池狀態 @Override public boolean isActive() { return isActive; } // 定時檢查連線池情況 @Override public void cheackPool() { if(dbBean.isCheakPool()){ new Timer().schedule(new TimerTask() { @Override public void run() { // 1.對執行緒裡面的連線狀態 // 2.連線池最小 最大連線數 // 3.其他狀態進行檢查，因為這裡還需要寫幾個執行緒管理的類，暫時就不新增了 System.out.println("空線池連線數："+freeConnection.size()); System.out.println("活動連線數：："+activeConnection.size()); System.out.println("總的連線數："+contActive); } },dbBean.getLazyCheck(),dbBean.getPeriodCheck()); } } }
Why ThreadLocal?
無論如何，要編寫一個多執行緒安全(Thread-safe)的程式是困難的，為了讓執行緒共享資源，必須小心地對共享資源進行同步，同步帶來一定的效能延遲，而另一方面，在處理同步的時候，又要注意物件的鎖定與釋放，避免產生死結，種種因素都使得編寫多執行緒程式變得困難。
嘗試從另一個角度來思考多執行緒共享資源的問題，既然共享資源這麼困難，那麼就乾脆不要共享，何不為每個執行緒創造一個資源的複本。將每一個執行緒存取資料的行為加以隔離，實現的方法就是給予每個執行緒一個特定空間來保管該執行緒所獨享的資源
什麼是ThreadLocal？
顧名思義它是local variable（執行緒區域性變數）。它的功用非常簡單，就是為每一個使用該變數的執行緒都提供一個變數值的副本，是每一個執行緒都可以獨立地改變自己的副本，而不會和其它執行緒的副本衝突。從執行緒的角度看，就好像每一個執行緒都完全擁有該變數。
使用場景
- To keep state with a thread (user-id, transaction-id, logging-id)
- To cache objects which you need frequently
ThreadLocal類 實現執行緒範圍的共享變數
它主要由四個方法組成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，該方法是一個protected的方法，顯然是為了子類重寫而特意實現的。該方法返回當前執行緒在該執行緒區域性變數的初始值，這個方法是一個延遲呼叫方法，在一個執行緒第1次呼叫get()或者set(Object)時才執行，並且僅執行1次。ThreadLocal中的確實實現直接返回一個null：
ThreadLocal的原理
ThreadLocal是如何做到為每一個執行緒維護變數的副本的呢？其實實現的思路很簡單，在ThreadLocal類中有一個Map，用於儲存每一個執行緒的變數的副本。比如下面的示例實現：
public class ThreadLocal
{
private Map values = Collections.synchronizedMap(new HashMap());
public Object get()
{
Thread curThread = Thread.currentThread();
Object o = values.get(curThread);
if (o == null && !values.containsKey(curThread))
{
o = initialValue();
values.put(curThread, o);
}
return o;
}
public void set(Object newValue)
{
values.put(Thread.currentThread(), newValue);
}
public Object initialValue()
{
return null;
}
}
ThreadLocal 的使用
使用方法一：
hibernate的文件時看到了關於使ThreadLocal管理多執行緒訪問的部分。具體程式碼如下
1. public static final ThreadLocal session = new ThreadLocal();
2. public static Session currentSession() {
3. Session s = (Session)session.get();
4. //open a new session,if this session has none
5. if(s == null){
6. s = sessionFactory.openSession();
7. session.set(s);
8. }
return s;
9. }
我們逐行分析
1。 初始化一個ThreadLocal物件，ThreadLocal有三個成員方法 get()、set()、initialvalue()。
如果不初始化initialvalue，則initialvalue返回null。
3。 session的get根據當前執行緒返回其對應的執行緒內部變數，也就是我們需要的net.sf.hibernate.Session（相當於對應每個資料庫連線）.多執行緒情況下共享資料庫連結是不安全的。ThreadLocal保證了每個執行緒都有自己的s（資料庫連線）。
5。如果是該執行緒初次訪問，自然，s（資料庫連線）會是null，接著建立一個Session，具體就是行6。
6。建立一個資料庫連線例項 s
7。儲存該資料庫連線s到ThreadLocal中。
8。如果當前執行緒已經訪問過資料庫了，則從session中get()就可以獲取該執行緒上次獲取過的連線例項。
使用方法二
當要給執行緒初始化一個特殊值時，需要自己實現ThreadLocal的子類並重寫該方法，通常使用一個內部匿名類對ThreadLocal進行子類化，EasyDBO中建立jdbc連線上下文就是這樣做的：
public class JDBCContext{
private static Logger logger = Logger.getLogger(JDBCContext.class);
private DataSource ds;
protected Connection connection;
private boolean isValid = true;
private static ThreadLocal jdbcContext;
private JDBCContext(DataSource ds){
this.ds = ds;
createConnection();
}
public static JDBCContext getJdbcContext(javax.sql.DataSource ds)
{
if(jdbcContext==null)jdbcContext=new JDBCContextThreadLocal(ds);
JDBCContext context = (JDBCContext) jdbcContext.get();
if (context == null) {
context = new JDBCContext(ds);
}
return context;
}
private static class JDBCContextThreadLocal extends ThreadLocal {
public javax.sql.DataSource ds;
public JDBCContextThreadLocal(javax.sql.DataSource ds)
{
this.ds=ds;
}
protected synchronized Object initialValue() {
return new JDBCContext(ds);
}
}
}
使用單例模式，不同的執行緒呼叫getJdbcContext()獲得自己的jdbcContext，都是通過JDBCContextThreadLocal 內建子類來獲得JDBCContext物件的執行緒區域性變數
本文部分轉自http://blog.csdn.net/wenzhihui_2010/article/details/8985575