2. 程式人生 > >java jdbc深入理解（connection與threadlocal與資料庫連線池和事務實）

java jdbc深入理解（connection與threadlocal與資料庫連線池和事務實）

阿新 • • 發佈：2019-02-13

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。

  1.  // 將執行緒和連線繫結，保證事務能統一執行  
  2.  成員變數   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>();
  1.  // 將執行緒和連線繫結，保證事務能統一執行
  2.     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

相關推薦

java jdbc深入理解（connection與threadlocal與資料庫連線池和事務實）

1.jdbc連線資料庫，就這樣子Class.forName("com.mysql.jdbc.Driver"); java.sql.Connection conn = DriverManager.getConnection(jdbcUrl);2.通過傳入jdbc url用Drivermanager.getC

Java 集合深入理解（4）：List 介面

在 Java 集合深入理解：Collection 中我們熟悉了 Java 集合框架的基本概念和優點，也瞭解了根介面之一的 Collection，這篇文章來加深 Collection 的子介面之一 List 的熟悉。 List 介面 一個 List 是一個元素有

Java 集合深入理解（3）：Collection

今天心情有點粉，來學學 Collection 吧！ 什麼是集合？ 集合，或者叫容器，是一個包含多個元素的物件； 集合可以對資料進行儲存，檢索，操作； 它們可以把許多個體組織成一個整體： 比如一副撲克牌（許多牌組成的集合）; 比如一個電話本

Java 集合深入理解（9）：Queue 佇列

今天心情不太好，來學一下 List 吧！ 什麼是佇列 佇列是資料結構中比較重要的一種型別，它支援 FIFO，尾部新增、頭部刪除（先進佇列的元素先出佇列），跟我們生活中的排隊類似。 佇列有兩種： 單佇列 迴圈佇列 單佇

Java 集合深入理解（14）：Map 概述

終於把 List 常用的幾種容器介紹完了，接下來開始 Map 的相關介紹。 什麼是 Map Java 中的 Map 介面 是和 Collection 介面 同一等級的集合根介面，它 表示一個鍵值對 (key-value) 的對映。類似數學

Java 集合深入理解（17）：HashMap 在 JDK 1.8 後新增的紅黑樹結構

上篇文章我們介紹了 HashMap 的主要特點和關鍵方法原始碼解讀，這篇文章我們介紹 HashMap 在 JDK1.8 新增樹形化相關的內容。 讀完本文你將瞭解到： 傳統 HashMap 的缺點 JDK 1.8 以前 HashMap 的實

Java 集合深入理解（7）：ArrayList

今天心情有點美麗，學學 ArrayList 放鬆下吧！ 什麼是 ArrayList ArrayList 是 Java 集合框架中 List介面 的一個實現類。 可以說 ArrayList 是我們使用最多的 List 集合，它

Java 集合深入理解（15）：AbstractMap

今天來了解下 AbstractMap。 什麼是 AbstractMap AbstractMap 是 Map 介面的的實現類之一，也是 HashMap, TreeMap, ConcurrentHashMap 等類的父類。 Abst

Java 集合深入理解（6）：AbstractList

今天心情比天藍，來學學 AbstractList 吧！ 什麼是 AbstractList AbstractList 繼承自 AbstractCollection 抽象類，實現了 List 介面 ，是 ArrayList 和 Abstr

封裝一個數據庫連線池工具類(connection與threadlocal與資料庫連線池和事務)

package com.itheima.utils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.St

Java 使用動態代理和觀察者模式+threadlocal實現資料庫連線池

當我們使用資料庫連線池時，如果多執行緒連線資料庫時，當超過5個執行緒連線資料庫時，那麼在第6個執行緒包括之後就連線不到資料庫了，該怎麼處理。 這裡用了java動態代理來這裡用了java的動態代理來代理資料庫的連線，攔截連線的close方法。並且給代理的連線加上一

springmvc（五）整合阿里 druid資料庫連線池和事務等配置，整合mybatis

感謝我們的小領導，他在研究，我們在套用，他走了以後再沒有完善過，一直沿用至今。如果看這裡的朋友有什麼需要整合進來的，不吝賜教，謝謝各位了。 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http:

【小家Java】深入理解Java列舉型別(enum)及7種常見的用法（含EnumMap和EnumSet）

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

Java併發-深入理解ThreadLocal

一、ThreadLocal是什麼？ ThreadLocal與執行緒同步機制不同，執行緒同步機制是多個執行緒共享同一個變數，而ThreadLocal是為每一個執行緒建立一個單獨的變數副本，故而每個執行緒都可以獨立地改變自己所擁有的變數副本，而不會影響其他執行緒所對應的副本。可以

深入理解vue中的slot與slot-scope （簡單易懂）

走在前端的大道上 插槽，也就是slot，是元件的一塊HTML模板，這塊模板顯示不顯示、以及怎樣顯示由父元件來決定。 實際上，一個slot最核心的兩個問題在這裡就點出來了，是顯示不顯示和怎樣顯示。 由於插槽是一塊模板，所以，對於任何一個元件，從模板種類的角度來分，其實都可以

《深入理解Spark：核心思想與原始碼分析》（第2章）

《深入理解Spark：核心思想與原始碼分析》一書第一章的內容請看連結《第1章 環境準備》 本文主要展示本書的第2章內容： Spark設計理念與基本架構 “若夫乘天地之正，而御六氣之辯，以遊無窮者，彼且惡乎待哉？” ——《莊子·逍遙遊》 n本章導讀： 上一章，介紹了Spark環境的搭建，為方便讀

《深入理解Spark：核心思想與原始碼分析》（前言及第1章）

　　自己犧牲了7個月的週末和下班空閒時間，通過研究Spark原始碼和原理，總結整理的《深入理解Spark：核心思想與原始碼分析》一書現在已經正式出版上市，目前亞馬遜、京東、噹噹、天貓等網站均有銷售，歡迎感興趣的同學購買。我開始研究原始碼時的Spark版本是1.2.0，經過7個多月的研究和出版社近4個月的流

《深入理解SPARK：核心思想與原始碼分析》——SparkContext的初始化（仲篇）——SparkUI、環境變數及排程

《深入理解Spark：核心思想與原始碼分析》一書第一章的內容請看連結《第1章 環境準備》 《深入理解Spark：核心思想與原始碼分析》一書第二章的內容請看連結《第2章 SPARK設計理念與基本架構》 由於本書的第3章內容較多，所以打算分別開闢四篇隨筆分別展現。 本文展現第3章第二部分的內容：

《深入理解Spark：核心思想與原始碼分析》——SparkContext的初始化（伯篇）——執行環境與元資料清理器

《深入理解Spark：核心思想與原始碼分析》一書第一章的內容請看連結《第1章 環境準備》 《深入理解Spark：核心思想與原始碼分析》一書第二章的內容請看連結《第2章 SPARK設計理念與基本架構》 由於本書的第3章內容較多，所以打算分別開闢四篇隨筆分別展現。本文展現第3章第一部分的內容： 第3章

int與unsigned等轉換深入理解（二）

1、隱式轉換C在以下四種情況下會進行隱式轉換:       1、算術運算式中，低型別能夠轉換為高型別。       2、賦值表示式中，右邊表示式的值自動隱式轉換為左邊變數的型別，並賦值給他。       3、函式呼叫中引數傳遞時，系統隱式地將實參轉換為形參的型別後，賦給形參