java jdbc深入理解（connection與threadlocal與數據庫連接池和事務實）

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（線程局部變量）。它的功用非常簡單，就是為每一個使用該變量的線程都提供一個變量值的副本，是每一個線程都可以獨立地改變自己的副本，而不會和其它線程的副本沖突。從線程的角度看，就好像每一個線程都完全擁有該變量。

使用場景

1. To keep state with a thread (user-id, transaction-id, logging-id)
2. 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