数据库连接池Java实现小结

原创 2004年09月14日 16:34:00
   因为工作需要要使用到连接池,所以拜读了互联网上众多前辈的文章,学了不少经验,这里想做一个小结,加上自己的想法和在一起,希望能给大家一些帮助。 



  目的:



消除数据库频繁连接带来的开销和瓶颈。 

  解决方案:



不过多的限制用户的使用,既不能太多的要求用户按规定的方法得到和使用数据库连 

尽量保持用户的习惯 

  目前的很多方法都是要求用户只能按规定方法使用连接,不能使用直接关闭数据连接的方法。解决办法就是使用代理类,来中间解决。可以参考http://www-900.ibm.com/developerWorks/cn/java/l-connpoolproxy/index.shtml





能维护连接的正常状态 





要求用户按规定的方法得到和使用数据库连 

尽量保持用户的习惯 

  目前的很多方法都是要求用户只能按规定方法使用连接,不能使用直接关闭数据连接的方法。解决办法就是使用代理类,来中间解决。可以参考http://www-900.ibm.com/developerWorks/cn/java/l-connpoolproxy/index.shtml





能维护连接的正常状态 

  因为针对数据库连接创建的资源,如果不能及时的释放,就会影响下一次数据连接的使用。例如在sql 2k中,一个连接不同创建多条Statement否则操作时会有数据连接占线的异常,所以必须在归还连接以后释放这些资源。 

//判断是使用了createStatement语句

if (CREATESTATE.equals(method.getName()))

{

obj = method.invoke(conn, args);

statRef = (Statement)obj;//记录语句

return obj;

}









  //判断是否调用了close的方法,如果调用close方法则把连接置为无用状态

if(CLOSE.equals(method.getName()))

{

//设置不使用标志

setIsFree(false);

//检查是否有后续工作,清除该连接无用资源

if (statRef != null)

statRef.close();

if (prestatRef != null)

prestatRef.close();

return null;

}









正确保护类不被违例使用 

一个考虑就是不能让用户随便使用代理类,而只能自己使用,一个就是用内部私有类,一个就是使用只有指定类才能调用的标志。我的实现就是采用后者。



/**

* 创建连接的工厂,只能让工厂调用

* @param factory 要调用工厂,并且一定被正确初始化

* @param param 连接参数

* @return 连接

*/

static public _Connection getConnection(ConnectionFactory factory, ConnectionParam param)

{

if (factory.isCreate())//判断是否正确初始化的工厂

{

_Connection _conn = new _Connection(param);

return _conn;

}

else

return null;

}









提供良好的用户接口,简单实用 

  使用静态方法创建工厂,然后来得到连接,使用完全和普通的Connection方法一样,没有限制。同时为了方便,设置了连接参数类和工厂参数类。

ConnectionParam param = new ConnectionParam(driver,url,user,password);

ConnectionFactory cf = null;//new ConnectionFactory(param, new FactoryParam());

try{

cf = new ConnectionFactory(param,new FactoryParam());

Connection conn1 = cf.getFreeConnection();

Connection conn2 = cf.getFreeConnection();

Connection conn3 = cf.getFreeConnection();

Statement stmt = conn1.createStatement();

ResultSet rs = stmt.executeQuery("select * from requests");

if (rs.next())

{

System.out.println("conn1 y"); 

}

else

{

System.out.println("conn1 n"); 



stmt.close();

conn1.close(); 







为了实现连接池的正常运作,使用了单态模 

  /**

* 使用指定的参数创建一个连接池

*/

public ConnectionFactory(ConnectionParam param, FactoryParam fparam)

throws SQLException 

{

//不允许参数为空

if ((param == null)||(fparam == null))

throw new SQLException("ConnectionParam和FactoryParam不能为空");

if (m_instance == null)

{

synchronized(ConnectionFactory.class){

if (m_instance == null)

{

//new instance

//参数定制

m_instance = new ConnectionFactory();

m_instance.connparam = param;

m_instance.MaxConnectionCount = fparam.getMaxConn();

m_instance.MinConnectionCount = fparam.getMinConn();

m_instance.ManageType = fparam.getType();

m_instance.isflag = true;

//初始化,创建MinConnectionCount个连接

System.out.println("connection factory 创建!");

try{

for (int i=0; i < m_instance.MinConnectionCount; i++)

{

_Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);

if (_conn == null) continue;

System.out.println("connection创建");

m_instance.FreeConnectionPool.add(_conn);//加入空闲连接池

m_instance.current_conn_count ++;

//标志是否支持事务

m_instance.supportTransaction = _conn.isSupportTransaction(); 

}

}

catch(Exception e)

{

e.printStackTrace();

}

//根据策略判断是否需要查询

if (m_instance.ManageType != 0)

{

Thread t = new Thread(new FactoryMangeThread(m_instance));

t.start();



}

}

}

}









连接池的管理 

  对于连接池的管理,我是设想使用静态管理和动态管理两种策略,设置了最大限制,和恒定的连接数。使用了2个池,一个空闲池,一个使用池。静态就是使用的时候发现空闲连接不够再去检查。动态就是使用了一个线程定时检查。

//根据策略判断是否需要查询

if (m_instance.ManageType != 0)

{

Thread t = new Thread(new FactoryMangeThread(m_instance));

t.start();

}



//连接池调度线程

public class FactoryMangeThread implements Runnable {

ConnectionFactory cf = null;

long delay = 1000;

public FactoryMangeThread(ConnectionFactory obj)

{

cf = obj;

}

/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

public void run() {

while(true){

try{

Thread.sleep(delay);

}

catch(InterruptedException e){}

System.out.println("eeeee");

//判断是否已经关闭了工厂,那就退出监听

if (cf.isCreate())

cf.schedule();

else

System.exit(1);

}

}

}







最后给出完整的源代码:



  _Connectio.java

package scut.ailab.connectionpool;



import java.lang.reflect.*;

import java.sql.*;



/**

* @author youyongming

* 定义数据库连接的代理类

*/

public class _Connection implements InvocationHandler {

//定义连接

private Connection conn = null;

//定义监控连接创建的语句

private Statement statRef = null;

private PreparedStatement prestatRef = null;

//是否支持事务标志

private boolean supportTransaction = false;

//数据库的忙状态

private boolean isFree = false;

//最后一次访问时间

long lastAccessTime = 0;

//定义要接管的函数的名字

String CREATESTATE = "createStatement";

String CLOSE = "close";

String PREPARESTATEMENT = "prepareStatement";

String COMMIT = "commit";

String ROLLBACK = "rollback";



/**

* 构造函数,采用私有,防止被直接创建

* @param param 连接参数

*/

private _Connection(ConnectionParam param) {

//记录日至



try{

//创建连接

Class.forName(param.getDriver()).newInstance();

conn = DriverManager.getConnection(param.getUrl(),param.getUser(), param.getPassword()); 

DatabaseMetaData dm = null;

dm = conn.getMetaData();

//判断是否支持事务

supportTransaction = dm.supportsTransactions();

}

catch(Exception e)

{

e.printStackTrace();

}

}





/* (non-Javadoc)

* @see java.lang.reflect.InvocationHandler#invoke

 *(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])

*/

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

Object obj = null;

//判断是否调用了close的方法,如果调用close方法则把连接置为无用状态

if(CLOSE.equals(method.getName()))

{

//设置不使用标志

setIsFree(false);

//检查是否有后续工作,清除该连接无用资源

if (statRef != null)

statRef.close();

if (prestatRef != null)

prestatRef.close();

return null;

}

//判断是使用了createStatement语句

if (CREATESTATE.equals(method.getName()))

{

obj = method.invoke(conn, args);

statRef = (Statement)obj;//记录语句

return obj;

}

//判断是使用了prepareStatement语句

if (PREPARESTATEMENT.equals(method.getName()))

{

obj = method.invoke(conn, args);

prestatRef = (PreparedStatement)obj;

return obj;

}

//如果不支持事务,就不执行该事物的代码

if ((COMMIT.equals(method.getName())||ROLLBACK.equals(method.getName()))

&& (!isSupportTransaction()))

return null; 

obj = method.invoke(conn, args); 

//设置最后一次访问时间,以便及时清除超时的连接

lastAccessTime = System.currentTimeMillis();

return obj;

}



/**

* 创建连接的工厂,只能让工厂调用

* @param factory 要调用工厂,并且一定被正确初始化

* @param param 连接参数

* @return 连接

*/

static public _Connection getConnection(ConnectionFactory factory, ConnectionParam param)

{

if (factory.isCreate())//判断是否正确初始化的工厂

{

_Connection _conn = new _Connection(param);

return _conn;

}

else

return null;

}



public Connection getFreeConnection() {

//返回数据库连接conn的接管类,以便截住close方法

Connection conn2 = (Connection)Proxy.newProxyInstance(

conn.getClass().getClassLoader(),

conn.getClass().getInterfaces(),this);

return conn2;

}



/**

* 该方法真正的关闭了数据库的连接

* @throws SQLException

*/

void close() throws SQLException{

//由于类属性conn是没有被接管的连接,因此一旦调用close方法后就直接关闭连接

conn.close();

}



public void setIsFree(boolean value)

{

isFree = value;

}



public boolean isFree() {

return isFree;



/**

* 判断是否支持事务

* @return boolean

*/

public boolean isSupportTransaction() {

return supportTransaction;



}









  ConnectionFactory.java 



  package scut.ailab.connectionpool;



/**

* @author youyongming

*

*/

import java.util.LinkedHashSet;

import java.sql.*;

import java.util.Iterator;



public class ConnectionFactory {

private static ConnectionFactory m_instance = null;

//在使用的连接池

private LinkedHashSet ConnectionPool = null;

//空闲连接池

private LinkedHashSet FreeConnectionPool = null;

//最大连接数

private int MaxConnectionCount = 4;

//最小连接数

private int MinConnectionCount = 2;

//当前连接数

private int current_conn_count = 0;

//连接参数

private ConnectionParam connparam = null;

//是否创建工厂的标志

private boolean isflag = false;

//是否支持事务

private boolean supportTransaction = false;

//定义管理策略

private int ManageType = 0;



private ConnectionFactory() {

ConnectionPool = new LinkedHashSet();

FreeConnectionPool = new LinkedHashSet();

}



/**

* 使用指定的参数创建一个连接池

*/

public ConnectionFactory(ConnectionParam param, FactoryParam fparam)

throws SQLException 

{

//不允许参数为空

if ((param == null)||(fparam == null))

throw new SQLException("ConnectionParam和FactoryParam不能为空");

if (m_instance == null)

{

synchronized(ConnectionFactory.class){

if (m_instance == null)

{

//new instance

//参数定制

m_instance = new ConnectionFactory();

m_instance.connparam = param;

m_instance.MaxConnectionCount = fparam.getMaxConn();

m_instance.MinConnectionCount = fparam.getMinConn();

m_instance.ManageType = fparam.getType();

m_instance.isflag = true;

//初始化,创建MinConnectionCount个连接

System.out.println("connection factory 创建!");

try{

for (int i=0; i < m_instance.MinConnectionCount; i++)

{

_Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);

if (_conn == null) continue;

System.out.println("connection创建");

m_instance.FreeConnectionPool.add(_conn);//加入空闲连接池

m_instance.current_conn_count ++;

//标志是否支持事务

m_instance.supportTransaction = _conn.isSupportTransaction(); 

}

}

catch(Exception e)

{

e.printStackTrace();

}

//根据策略判断是否需要查询

if (m_instance.ManageType != 0)

{

Thread t = new Thread(new FactoryMangeThread(m_instance));

t.start();



}

}

}

}



/**

* 标志工厂是否已经创建

* @return boolean

*/ 

public boolean isCreate()

{

return m_instance.isflag;

}



/**

* 从连接池中取一个空闲的连接

* @return Connection

* @throws SQLException

*/

public synchronized Connection getFreeConnection() 

throws SQLException

{

Connection conn = null;

//获取空闲连接

Iterator iter = m_instance.FreeConnectionPool.iterator();

while(iter.hasNext()){

_Connection _conn = (_Connection)iter.next();

//找到未用连接

if(!_conn.isFree()){

conn = _conn.getFreeConnection();

_conn.setIsFree(true);

//移出空闲区

m_instance.FreeConnectionPool.remove(_conn);

//加入连接池 

m_instance.ConnectionPool.add(_conn); 

break;

}

}

//检查空闲池是否为空

if (m_instance.FreeConnectionPool.isEmpty())

{

//再检查是否能够分配

if (m_instance.current_conn_count < m_instance.MaxConnectionCount)

{

//新建连接到空闲连接池

int newcount = 0 ;

//取得要建立的数目

if (m_instance.MaxConnectionCount - m_instance.current_conn_count >=

         m_instance.MinConnectionCount)

{

newcount = m_instance.MinConnectionCount;

}

else

{

newcount = m_instance.MaxConnectionCount - m_instance.current_conn_count;

}

//创建连接

for (int i=0;i <newcount; i++)

{

_Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);

m_instance.FreeConnectionPool.add(_conn);

m_instance.current_conn_count ++;

}

}

else

{//如果不能新建,检查是否有已经归还的连接

iter = m_instance.ConnectionPool.iterator();

while(iter.hasNext()){

_Connection _conn = (_Connection)iter.next();

if(!_conn.isFree()){

conn = _conn.getFreeConnection();

_conn.setIsFree(false);

m_instance.ConnectionPool.remove(_conn); 

m_instance.FreeConnectionPool.add(_conn); 

break;

}



}

}//if (FreeConnectionPool.isEmpty())

//再次检查是否能分配连接

if(conn == null){

iter = m_instance.FreeConnectionPool.iterator();

while(iter.hasNext()){

_Connection _conn = (_Connection)iter.next();

if(!_conn.isFree()){

conn = _conn.getFreeConnection();

_conn.setIsFree(true);

m_instance.FreeConnectionPool.remove(_conn); 

m_instance.ConnectionPool.add(_conn); 

break;

}

}

if(conn == null)//如果不能则说明无连接可用

throw new SQLException("没有可用的数据库连接");

}

System.out.println("get connection");

return conn;

}



/**

* 关闭该连接池中的所有数据库连接

* @throws SQLException

*/

public synchronized void close() throws SQLException

{

this.isflag = false;

SQLException excp = null;

//关闭空闲池

Iterator iter = m_instance.FreeConnectionPool.iterator();

while(iter.hasNext()){

try{

((_Connection)iter.next()).close();

System.out.println("close connection:free");

m_instance.current_conn_count --;

}catch(Exception e){

if(e instanceof SQLException)

excp = (SQLException)e;

}

}

//关闭在使用的连接池

iter = m_instance.ConnectionPool.iterator();

while(iter.hasNext()){

try{

((_Connection)iter.next()).close();

System.out.println("close connection:inused");

m_instance.current_conn_count --;

}catch(Exception e){

if(e instanceof SQLException)

excp = (SQLException)e;

}



if(excp != null)

throw excp;





/**

* 返回是否支持事务

* @return boolean

*/

public boolean isSupportTransaction() {

return m_instance.supportTransaction;



/**

* 连接池调度管理

*

*/

public void schedule()

{

Connection conn = null;

//再检查是否能够分配

Iterator iter = null;

//检查是否有已经归还的连接

{

iter = m_instance.ConnectionPool.iterator();

while(iter.hasNext()){

_Connection _conn = (_Connection)iter.next();

if(!_conn.isFree()){

conn = _conn.getFreeConnection();

_conn.setIsFree(false);

m_instance.ConnectionPool.remove(_conn); 

m_instance.FreeConnectionPool.add(_conn); 

break;

}



}

if (m_instance.current_conn_count < m_instance.MaxConnectionCount)

{

//新建连接到空闲连接池

int newcount = 0 ;

//取得要建立的数目

if (m_instance.MaxConnectionCount - m_instance.current_conn_count

    >=m_instance.MinConnectionCount)

{

newcount = m_instance.MinConnectionCount;

}

else

{

newcount = m_instance.MaxConnectionCount - m_instance.current_conn_count;

}

//创建连接

for (int i=0;i <newcount; i++)

{

_Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);

m_instance.FreeConnectionPool.add(_conn);

m_instance.current_conn_count ++;

}

}

}

}



  ConnectionParam.java 



  package scut.ailab.connectionpool;



import java.io.Serializable;



/**

* @author youyongming

* 实现数据库连接的参数类

*/

public class ConnectionParam implements Serializable {

private String driver; //数据库驱动程序

private String url; //数据连接的URL

private String user; //数据库用户名

private String password; //数据库密码



/**

* 唯一的构造函数,需要指定连接的四个必要参数

* @param driver 数据驱动

* @param url 数据库连接url

* @param user 用户名

* @param password 密码

*/

public ConnectionParam(String driver,String url,String user,String password)

{

this.driver = driver;

this.url = url;

this.user = user;

this.password = password;

}



public String getDriver() {

return driver;

}



public String getPassword() {

return password;

}



public String getUrl() {

return url;

}



public String getUser() {

return user;

}



public void setDriver(String driver) {

this.driver = driver;

}



public void setPassword(String password) {

this.password = password;

}



public void setUrl(String url) {

this.url = url;

}



public void setUser(String user) {

this.user = user;

}



/**

* @see java.lang.Object#clone()

*/

public Object clone(){

ConnectionParam param = new ConnectionParam(driver,url,user,password);

return param;

}



/**

* @see java.lang.Object#equals(java.lang.Object)

*/

public boolean equals(Object obj) {

if(obj instanceof ConnectionParam){

ConnectionParam param = (ConnectionParam)obj;

return ((driver.compareToIgnoreCase(param.getDriver()) == 0)&&

(url.compareToIgnoreCase(param.getUrl()) == 0)&&

(user.compareToIgnoreCase(param.getUser()) == 0)&&

(password.compareToIgnoreCase(param.getPassword()) == 0));

}

return false;

}

}









  FactoryMangeThread.java 



  /*

* Created on 2003-5-13

*

* To change the template for this generated file go to

* Window>Preferences>Java>Code Generation>Code and Comments

*/

package scut.ailab.connectionpool;



/**

* @author youyongming

*

*/

//连接池调度线程

public class FactoryMangeThread implements Runnable {

ConnectionFactory cf = null;

long delay = 1000;

public FactoryMangeThread(ConnectionFactory obj)

{

cf = obj;

}

/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

public void run() {

while(true){

try{

Thread.sleep(delay);

}

catch(InterruptedException e){}

System.out.println("eeeee");

//判断是否已经关闭了工厂,那就退出监听

if (cf.isCreate())

cf.schedule();

else

System.exit(1);

}

}

}









  FactoryParam.java 



  /*

* Created on 2003-5-13

*

* To change the template for this generated file go to

* Window>Preferences>Java>Code Generation>Code and Comments

*/

package scut.ailab.connectionpool;



/**

* @author youyongming

*

*/

//连接池工厂参数

public class FactoryParam {

//最大连接数

private int MaxConnectionCount = 4;

//最小连接数

private int MinConnectionCount = 2; 

//回收策略

private int ManageType = 0;



public FactoryParam() {

}



/**

* 构造连接池工厂参数的对象

* @param max 最大连接数

* @param min 最小连接数

* @param type 管理策略

*/

public FactoryParam(int max, int min, int type)

{

this.ManageType = type;

this.MaxConnectionCount = max;

this.MinConnectionCount = min;

}



/**

* 设置最大的连接数

* @param value

*/

public void setMaxConn(int value)

{

this.MaxConnectionCount = value;

}

/**

* 获取最大连接数

* @return

*/

public int getMaxConn()

{

return this.MaxConnectionCount;

}

/**

* 设置最小连接数

* @param value

*/

public void setMinConn(int value)

{

this.MinConnectionCount = value;

}

/**

* 获取最小连接数

* @return

*/

public int getMinConn()

{

return this.MinConnectionCount;

}

public int getType()

{

return this.ManageType;

}

}







  testmypool.java 



  /*

* Created on 2003-5-13

*

* To change the template for this generated file go to

* Window>Preferences>Java>Code Generation>Code and Comments

*/

package scut.ailab.connectionpool;



/**

* @author youyongming

*

*/

import java.sql.*;



public class testmypool {



public void test1()

{

String user = "DevTeam";

String password = "DevTeam";

String driver = "sun.jdbc.odbc.JdbcOdbcDriver";

String url = "jdbc:odbc:gfqh2";

ConnectionParam param = new ConnectionParam(driver,url,user,password);

ConnectionFactory cf = null;//new ConnectionFactory(param, new FactoryParam());

try{

cf = new ConnectionFactory(param,new FactoryParam());

Connection conn1 = cf.getFreeConnection();

Connection conn2 = cf.getFreeConnection();

Connection conn3 = cf.getFreeConnection();

Statement stmt = conn1.createStatement();

ResultSet rs = stmt.executeQuery("select * from requests");

if (rs.next())

{

System.out.println("conn1 y"); 

}

else

{

System.out.println("conn1 n"); 



stmt.close();

conn1.close(); 

Connection conn4 = cf.getFreeConnection();

Connection conn5 = cf.getFreeConnection();

stmt = conn5.createStatement();

rs = stmt.executeQuery("select * from requests");

if (rs.next())

{

System.out.println("conn5 y"); 

}

else

{

System.out.println("conn5 n"); 



conn2.close();

conn3.close();

conn4.close();

conn5.close();

}

catch(Exception e)

{

e.printStackTrace();

}

finally{

try{

cf.close();

}

catch(Exception e)

{

e.printStackTrace();

}



}

public static void main(String[] args) {

String user = "DevTeam";

String password = "DevTeam";

String driver = "sun.jdbc.odbc.JdbcOdbcDriver";

String url = "jdbc:odbc:gfqh2";

ConnectionParam param = new ConnectionParam(driver,url,user,password);

ConnectionFactory cf = null;//new ConnectionFactory(param,new FactoryParam());

try{

cf = new ConnectionFactory(param,new FactoryParam());

ConnectionFactory cf1= new ConnectionFactory(param,new FactoryParam());

Connection conn1 = null;

long time = System.currentTimeMillis();

for (int i=0; i <10;i++)

{

conn1 = cf.getFreeConnection();

Statement stmt = conn1.createStatement();

ResultSet rs = stmt.executeQuery("select * from requests");

if (rs.next())

{

System.out.println("conn1 y"); 

}

else

{

System.out.println("conn1 n"); 



conn1.close(); 

}

System.out.println("pool:" + (System.currentTimeMillis()-time));

time = System.currentTimeMillis();

Class.forName(param.getDriver()).newInstance();

for (int i=0; i <10;i++)

{

conn1 = DriverManager.getConnection(param.getUrl(),

      param.getUser(), param.getPassword()); 

Statement stmt = conn1.createStatement();

ResultSet rs = stmt.executeQuery("select * from requests");

if (rs.next())

{

System.out.println("conn1 y"); 

}

else

{

System.out.println("conn1 n"); 



conn1.close(); 



System.out.println("no pool:" + (System.currentTimeMillis()-time));

}

catch(Exception e)

{

e.printStackTrace();

}

finally{

try{

cf.close();

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

}

大二上学期小结

日子过的真的是快,转眼间又快到了放假的时候。这一学期,作为大二,好好体验了一把学长的滋味(不过也是挺难当的,毕竟怎么说也得做好这个榜样),看着以前写过的博客,号称自己皂兄,这一学期过去,我就得给自己改...
  • feizaoSYUACM
  • feizaoSYUACM
  • 2016年12月26日 13:22
  • 298

个人java小结

目今面临面试,而在面试中基础知识是相当重要的,故在此一边复习,一边总结一下下列个人认为重要的基础知识。本人现在面试了两场面试,第一场面试直接被技术长官刷下来,因为基础知识一点都不牢固,比如hashma...
  • a815331793
  • a815331793
  • 2013年07月31日 21:44
  • 507

Java中for循环的学习总结!

Java循环中的for循环简单示例: for 循环的语法结构: for(表达式1;表达式2;表达式3){ 循环语句 } for循环的执行流程是:       首先执行...
  • zgz15515397650
  • zgz15515397650
  • 2017年07月17日 21:20
  • 164

【学习总结】顺序表模拟约瑟夫问题

问题描述: n个人围坐在一起,从第s个人报数,报到数字为m的人出列。然后从出列的下一个人重新从1开始报数,数到m的人出列,依次类推……直到所有人都出列,求出列次序。//说明为了符合实际,数组下标为0...
  • chendongqaq
  • chendongqaq
  • 2017年03月23日 21:44
  • 337

线性表之单链表学习小结(初学数据结构必看)

花了好几个小时,详细规划出了整个过程,包括所有基本操作。。。有什么疑问请下方留言 #include using namespace std; #define ElemType char #d...
  • u014492609
  • u014492609
  • 2014年09月23日 22:12
  • 1322

Java继承学习小结

一、继承中构造方法的关系public class ConstructionMethodTest { public static void main(String[] args) { ...
  • liuweiballack
  • liuweiballack
  • 2015年07月22日 11:51
  • 323

JAVA部分面试题总结,部分答案不是很详细

1.Java中的callable和runnable的区别:        A:runnable和callable都代表在不同的线程中要执行的任务,runnable在jdk1.0开始就有了,call...
  • hynfq_
  • hynfq_
  • 2018年01月06日 19:14
  • 27

主流JS框架中DOMReady事件的实现

转载自:http://www.cnblogs.com/JulyZhang/archive/2011/02/12/1952484.html 在实际应用中,我们经常会遇到这样的场景,当页面加...
  • lijunlinlijunlin
  • lijunlinlijunlin
  • 2016年01月18日 01:27
  • 260

Java多线程基础总结

Java采用多线程方式实现并行计算,当然并行计算也可以采用多进程方式实现,但是进程切换耗费比较高。而且进程间是隔离的,进程间通信机制比较麻烦,最后JVM本身在操作系统中就一个进程,由它再启动一个进程不...
  • HackerSaillen
  • HackerSaillen
  • 2015年08月19日 08:53
  • 1116

数据结构课程总结

我想了好多,不知道从何写起,不是不知道写什么,而是想说的太多,不知道从何写起。。那就想到什么就说什么吧。   先说说我对慕课的看法吧,贺老师的翻转课堂不是我第一次接触慕课这个平台(不是智慧树),我第...
  • big_ice
  • big_ice
  • 2016年12月17日 21:38
  • 749
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数据库连接池Java实现小结
举报原因:
原因补充:

(最多只允许输入30个字)