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。

  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. 

  2. private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
    3. 



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. 

  2. To cache objects which you need frequently
    3. 



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
				


				
时间： 2024-12-09 22:08:55 

		


		


	

	
	

		


		
java jdbc深入理解（connection与threadlocal与数据库连接池和事务实）的相关文章


								

		

			

                在JAVA中实现JDBC数据库连接池
			

		

		

									

				[转自e良师益友网]Java程序员都很羡慕Windows ADO ,只需要new Connection 就可以直接从数据库连接池中返回Connection.并且 ADO Connection 是线程安全的,多个线程可以共用一个Connection,所以ASP程序一般都把getConnection 放在 Global.asa 文件中,在 IIS 启动时建立数据库连接.ADO 的Connection 和Result 都有很好的缓冲,并且很容易使用.推荐学习尚硅谷JDBC视频教程. 其实我们可以自己写			

		

	

				

		

			

                Java之中JDBC数据库连接池实现方法
			

		

		

									

				作为一名初级Java程序员都很羡慕Windows ADO ,只需要new Connection 就可以直接从数据库连接池中返回Connection.并且 ADO Connection 是线程安全的,多个线程可以共用一个Connection,所以ASP程序一般都把getConnection 放在 Global.asa 文件中,在 IIS 启动时建立数据库连接.ADO 的Connection 和Result 都有很好的缓冲,并且很容易使用. 其实我们可以自己写一个JDBC数据库连接池. 写JDBC			

		

	

				

		

			

                Java数据库连接池
			

		

		

									

				写了个 Java数据库连接池,具备基本的功能点: 1.对池中活动连接的重用. 2.池满时的适时等待. 3.对空闲连接的适时关闭. 抛砖引玉,不吝赐教. 源码文件 DBConnection.java 1 package db; 2 3 import java.sql.Connection; 4 import java.util.concurrent.atomic.AtomicBoolean; 5 6 /** 7 * 封装的连接 8 * @author Linkwork, [email protec			

		

	

				

		

			

                java数据库连接池技术简单使用
			

		

		

									

				JDBCDemo.java: package com.itheima.jdbc; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import com.itheima.pool.MyPool; public class JDBCDemo { public static void main(String[]			

		

	

				

		

			

                【Java】java数据库连接池配置的几种方法
			

		

		

									

				今天遇到了关于数据源连接池配置的问题,发现有很多种方式可以配置,现总结如下,希望对大家有所帮助:(已Mysql数据库为例) 一,Tomcat配置数据源: 方式一:在WebRoot下面建文件夹META-INF,里面建一个文件context.xml,内容如下: <Context>      <Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource" 			

		

	

				

		

			

                在Java中开源的数据库连接池
			

		

		

									

				在Java中开源的数据库连接池有以下几种 : 1, C3P0 C3P0是一个开放源代码的JDBC连接池,它在lib目录中与Hibernate一起发布,包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象. https://github.com/swaldman/c3p0 2,Proxool 这是一个Java SQL Driver驱动程序,提供了对你选择的其它类型的驱动程序的连接池封装.可以非常简单的移植到现存的代码中.完全可配			

		

	

				

		

			

                关于jdbc和数据库连接池的关系(不是封装的关系)
			

		

		

									

				你都说是数据库连接池了.那就是连接数据库用的.JDBC是java封装的对数据库的操作.当然你可以自己进一步封装.数据库连接池是JDBC使用的前提,如果连数据库连接池都没连上,JDBC的操作就谈不上了.而光有数据库连接池也没用啊,你连上了数据库不对其进行操作不是白连了么.所以就需要JDBC了. 一直没有搞清楚,JDBC的数据源与连接池是怎么一样的关系,直到今天做系统的时候,遇到了连接池如果管理有效的连接及资源的占用,释放的问题.    数据源并不等于连接池,它不是必须要求实现连接池的,即连接池是数			

		

	

				

		

			

                [数据库连接池二]Java数据库连接池--C3P0和JDNI.
			

		

		

									

				前言:上一篇文章中讲了DBCP的用法以及实现原理, 这一篇再来说下C3P0和JDNI的用法. 1.1.C3P0数据源 C3P0是一个开源的JDBC连接池,它实现了数据源和JNDI绑定,支持JDBC3规范和JDBC2的标准扩展.目前使用它的开源项目有Hibernate,Spring等.C3P0数据源在项目开发中使用得比较多. c3p0与dbcp区别 dbcp没有自动回收空闲连接的功能 c3p0有自动回收空闲连接功能 1.2.在应用程序中加入C3P0连接池 1.导入相关jar包    c3p0-0.			

		

	

				

		

			

                Java 数据库连接池—转载孤傲苍狼 http://www.cnblogs.com/xdp-gacl/p/4002804.html
			

		

		

									

				一.应用程序直接获取数据库连接的缺点 用户每次请求都需要向数据库获得链接,而数据库创建连接通常需要消耗相对较大的资源,创建时间也较长.假设网站一天10万访问量,数据库服务器就需要创建10万次连接,极大的浪费数据库的资源,并且极易造成数据库服务器内存溢出.拓机.如下图所示: 二.使用数据库连接池优化程序性能 2.1.数据库连接池的基本概念 数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性