java的几种连接池

连接池的管理用了了享元模式，这里对连接池进行简单设计。

一、设计思路

1.连接池配置属性DBbean：里面存放可以配置的一些属性

2.连接池接口IConnectionPool：里面定义一些基本的获取连接的一些方法

3.接口实现ConnectionPool：对上面操作进行实现，并加入一些其他方法

4.连接池管理ConnectionPoolManager：管理所有的不同的连接池，所有的连接都能通过这里进行获得连接

5.另外还有几个测试类，和连接信息模拟的类，这里就不进行xml 和配置文件信息的读取了

1. package pool;
2. /**
3. * 这是外部可以配置的连接池属性
4. * 可以允许外部配置，拥有默认值
5. * @author Ran
6. *
7. */
8. public class DBbean {
9. // 连接池属性
10. private String driverName;
11. private String url;
12. private String userName;
13. private String password;
14. // 连接池名字
15. private String poolName;
16. private int minConnections = ; // 空闲池，最小连接数
17. private int maxConnections = ; // 空闲池，最大连接数
18. private int initConnections = ;// 初始化连接数
19. private long connTimeOut = ;// 重复获得连接的频率
20. private int maxActiveConnections = ;// 最大允许的连接数，和数据库对应
21. private long connectionTimeOut = **;// 连接超时时间，默认20分钟
22. private boolean isCurrentConnection = true; // 是否获得当前连接，默认true
23. private boolean isCheakPool = true; // 是否定时检查连接池
24. private long lazyCheck = **;// 延迟多少时间后开始 检查
25. private long periodCheck = **;// 检查频率
26. public DBbean(String driverName, String url, String userName,
27. String password, String poolName) {
28. super();
29. this.driverName = driverName;
30. this.url = url;
31. this.userName = userName;
32. this.password = password;
33. this.poolName = poolName;
34. }
35. public DBbean() {
36. }
37. public String getDriverName() {
38. if(driverName == null){
39. driverName = this.getDriverName()+"_"+this.getUrl();
40. }
41. return driverName;
42. }
43. public void setDriverName(String driverName) {
44. this.driverName = driverName;
45. }
46. public String getUrl() {
47. return url;
48. }
49. public void setUrl(String url) {
50. this.url = url;
51. }
52. public String getUserName() {
53. return userName;
54. }
55. public void setUserName(String userName) {
56. this.userName = userName;
57. }
58. public String getPassword() {
59. return password;
60. }
61. public void setPassword(String password) {
62. this.password = password;
63. }
64. public String getPoolName() {
65. return poolName;
66. }
67. public void setPoolName(String poolName) {
68. this.poolName = poolName;
69. }
70. public int getMinConnections() {
71. return minConnections;
72. }
73. public void setMinConnections(int minConnections) {
74. this.minConnections = minConnections;
75. }
76. public int getMaxConnections() {
77. return maxConnections;
78. }
79. public void setMaxConnections(int maxConnections) {
80. this.maxConnections = maxConnections;
81. }
82. public int getInitConnections() {
83. return initConnections;
84. }
85. public void setInitConnections(int initConnections) {
86. this.initConnections = initConnections;
87. }
88. public int getMaxActiveConnections() {
89. return maxActiveConnections;
90. }
91. public void setMaxActiveConnections(int maxActiveConnections) {
92. this.maxActiveConnections = maxActiveConnections;
93. }
94. public long getConnTimeOut() {
95. return connTimeOut;
96. }
97. public void setConnTimeOut(long connTimeOut) {
98. this.connTimeOut = connTimeOut;
99. }
100. public long getConnectionTimeOut() {
101. return connectionTimeOut;
102. }
103. public void setConnectionTimeOut(long connectionTimeOut) {
104. this.connectionTimeOut = connectionTimeOut;
105. }
106. public boolean isCurrentConnection() {
107. return isCurrentConnection;
108. }
109. public void setCurrentConnection(boolean isCurrentConnection) {
110. this.isCurrentConnection = isCurrentConnection;
111. }
112. public long getLazyCheck() {
113. return lazyCheck;
114. }
115. public void setLazyCheck(long lazyCheck) {
116. this.lazyCheck = lazyCheck;
117. }
118. public long getPeriodCheck() {
119. return periodCheck;
120. }
121. public void setPeriodCheck(long periodCheck) {
122. this.periodCheck = periodCheck;
123. }
124. public boolean isCheakPool() {
125. return isCheakPool;
126. }
127. public void setCheakPool(boolean isCheakPool) {
128. this.isCheakPool = isCheakPool;
129. }
130. }

package pool;
/**
 * 这是外部可以配置的连接池属性
 * 可以允许外部配置，拥有默认值
 * @author Ran
 *
 */
public class DBbean {
	// 连接池属性
	private String driverName;
	private String url;
	private String userName;
	private String password;
	// 连接池名字
	private String poolName;
	private int minConnections = 1; // 空闲池，最小连接数
	private int maxConnections = 10; // 空闲池，最大连接数

	private int initConnections = 5;// 初始化连接数

	private long connTimeOut = 1000;// 重复获得连接的频率

	private int maxActiveConnections = 100;// 最大允许的连接数，和数据库对应

	private long connectionTimeOut = 1000*60*20;// 连接超时时间，默认20分钟

	private boolean isCurrentConnection = true; // 是否获得当前连接，默认true

	private boolean isCheakPool = true; // 是否定时检查连接池
	private long lazyCheck = 1000*60*60;// 延迟多少时间后开始 检查
	private long periodCheck = 1000*60*60;// 检查频率

	public DBbean(String driverName, String url, String userName,
			String password, String poolName) {
		super();
		this.driverName = driverName;
		this.url = url;
		this.userName = userName;
		this.password = password;
		this.poolName = poolName;
	}
	public DBbean() {
	}
	public String getDriverName() {
		if(driverName == null){
			driverName = this.getDriverName()+"_"+this.getUrl();
		}
		return driverName;
	}
	public void setDriverName(String driverName) {
		this.driverName = driverName;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getPoolName() {
		return poolName;
	}
	public void setPoolName(String poolName) {
		this.poolName = poolName;
	}
	public int getMinConnections() {
		return minConnections;
	}
	public void setMinConnections(int minConnections) {
		this.minConnections = minConnections;
	}
	public int getMaxConnections() {
		return maxConnections;
	}
	public void setMaxConnections(int maxConnections) {
		this.maxConnections = maxConnections;
	}
	public int getInitConnections() {
		return initConnections;
	}
	public void setInitConnections(int initConnections) {
		this.initConnections = initConnections;
	}

	public int getMaxActiveConnections() {
		return maxActiveConnections;
	}
	public void setMaxActiveConnections(int maxActiveConnections) {
		this.maxActiveConnections = maxActiveConnections;
	}
	public long getConnTimeOut() {
		return connTimeOut;
	}
	public void setConnTimeOut(long connTimeOut) {
		this.connTimeOut = connTimeOut;
	}
	public long getConnectionTimeOut() {
		return connectionTimeOut;
	}
	public void setConnectionTimeOut(long connectionTimeOut) {
		this.connectionTimeOut = connectionTimeOut;
	}
	public boolean isCurrentConnection() {
		return isCurrentConnection;
	}
	public void setCurrentConnection(boolean isCurrentConnection) {
		this.isCurrentConnection = isCurrentConnection;
	}
	public long getLazyCheck() {
		return lazyCheck;
	}
	public void setLazyCheck(long lazyCheck) {
		this.lazyCheck = lazyCheck;
	}
	public long getPeriodCheck() {
		return periodCheck;
	}
	public void setPeriodCheck(long periodCheck) {
		this.periodCheck = periodCheck;
	}
	public boolean isCheakPool() {
		return isCheakPool;
	}
	public void setCheakPool(boolean isCheakPool) {
		this.isCheakPool = isCheakPool;
	}

}

1. package pool;
2. import java.sql.Connection;
3. import java.sql.SQLException;
4. public interface IConnectionPool {
5. // 获得连接
6. public Connection  getConnection();
7. // 获得当前连接
8. public Connection getCurrentConnecton();
9. // 回收连接
10. public void releaseConn(Connection conn) throws SQLException;
11. // 销毁清空
12. public void destroy();
13. // 连接池是活动状态
14. public boolean isActive();
15. // 定时器，检查连接池
16. public void cheackPool();
17. }

package pool;

import java.sql.Connection;
import java.sql.SQLException;

public interface IConnectionPool {
	// 获得连接
	public Connection  getConnection();
	// 获得当前连接
	public Connection getCurrentConnecton();
	// 回收连接
	public void releaseConn(Connection conn) throws SQLException;
	// 销毁清空
	public void destroy();
	// 连接池是活动状态
	public boolean isActive();
	// 定时器，检查连接池
	public void cheackPool();
}

1. package pool;
2. import java.sql.Connection;
3. import java.sql.DriverManager;
4. import java.sql.SQLException;
5. import java.util.List;
6. import java.util.Timer;
7. import java.util.TimerTask;
8. import java.util.Vector;
9. public class ConnectionPool implements IConnectionPool {
10. // 连接池配置属性
11. private DBbean dbBean;
12. private boolean isActive = false; // 连接池活动状态
13. private int contActive = ;// 记录创建的总的连接数
14. // 空闲连接
15. private List<Connection> freeConnection = new Vector<Connection>();
16. // 活动连接
17. private List<Connection> activeConnection = new Vector<Connection>();
18. // 将线程和连接绑定，保证事务能统一执行
19. private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
20. public ConnectionPool(DBbean dbBean) {
21. super();
22. this.dbBean = dbBean;
23. init();
24. cheackPool();
25. }
26. // 初始化
27. public void init() {
28. try {
29. Class.forName(dbBean.getDriverName());
30. for (int i = ; i < dbBean.getInitConnections(); i++) {
31. Connection conn;
32. conn = newConnection();
33. // 初始化最小连接数
34. if (conn != null) {
35. freeConnection.add(conn);
36. contActive++;
37. }
38. }
39. isActive = true;
40. } catch (ClassNotFoundException e) {
41. e.printStackTrace();
42. } catch (SQLException e) {
43. e.printStackTrace();
44. }
45. }
46. // 获得当前连接
47. public Connection getCurrentConnecton(){
48. // 默认线程里面取
49. Connection conn = threadLocal.get();
50. if(!isValid(conn)){
51. conn = getConnection();
52. }
53. return conn;
54. }
55. // 获得连接
56. public synchronized Connection getConnection() {
57. Connection conn = null;
58. try {
59. // 判断是否超过最大连接数限制
60. if(contActive < this.dbBean.getMaxActiveConnections()){
61. if (freeConnection.size() > ) {
62. conn = freeConnection.get();
63. if (conn != null) {
64. threadLocal.set(conn);
65. }
66. freeConnection.remove();
67. } else {
68. conn = newConnection();
69. }
70. }else{
71. // 继续获得连接,直到从新获得连接
72. wait(this.dbBean.getConnTimeOut());
73. conn = getConnection();
74. }
75. if (isValid(conn)) {
76. activeConnection.add(conn);
77. contActive ++;
78. }
79. } catch (SQLException e) {
80. e.printStackTrace();
81. } catch (ClassNotFoundException e) {
82. e.printStackTrace();
83. } catch (InterruptedException e) {
84. e.printStackTrace();
85. }
86. return conn;
87. }
88. // 获得新连接
89. private synchronized Connection newConnection()
90. throws ClassNotFoundException, SQLException {
91. Connection conn = null;
92. if (dbBean != null) {
93. Class.forName(dbBean.getDriverName());
94. conn = DriverManager.getConnection(dbBean.getUrl(),
95. dbBean.getUserName(), dbBean.getPassword());
96. }
97. return conn;
98. }
99. // 释放连接
100. public synchronized void releaseConn(Connection conn) throws SQLException {
101. if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) {
102. freeConnection.add(conn);
103. activeConnection.remove(conn);
104. contActive --;
105. threadLocal.remove();
106. // 唤醒所有正待等待的线程，去抢连接
107. notifyAll();
108. }
109. }
110. // 判断连接是否可用
111. private boolean isValid(Connection conn) {
112. try {
113. if (conn == null || conn.isClosed()) {
114. return false;
115. }
116. } catch (SQLException e) {
117. e.printStackTrace();
118. }
119. return true;
120. }
121. // 销毁连接池
122. public synchronized void destroy() {
123. for (Connection conn : freeConnection) {
124. try {
125. if (isValid(conn)) {
126. conn.close();
127. }
128. } catch (SQLException e) {
129. e.printStackTrace();
130. }
131. }
132. for (Connection conn : activeConnection) {
133. try {
134. if (isValid(conn)) {
135. conn.close();
136. }
137. } catch (SQLException e) {
138. e.printStackTrace();
139. }
140. }
141. isActive = false;
142. contActive = ;
143. }
144. // 连接池状态
145. @Override
146. public boolean isActive() {
147. return isActive;
148. }
149. // 定时检查连接池情况
150. @Override
151. public void cheackPool() {
152. if(dbBean.isCheakPool()){
153. new Timer().schedule(new TimerTask() {
154. @Override
155. public void run() {
156. // 1.对线程里面的连接状态
157. // 2.连接池最小 最大连接数
158. // 3.其他状态进行检查，因为这里还需要写几个线程管理的类，暂时就不添加了
159. System.out.println("空线池连接数："+freeConnection.size());
160. System.out.println("活动连接数：："+activeConnection.size());
161. System.out.println("总的连接数："+contActive);
162. }
163. },dbBean.getLazyCheck(),dbBean.getPeriodCheck());
164. }
165. }
166. }

package pool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

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());
		}
	}
}

1. package pool;
2. import java.sql.Connection;
3. import java.sql.SQLException;
4. import java.util.Hashtable;
5. /**
6. * 连接管理类
7. * @author Ran
8. *
9. */
10. public class ConnectionPoolManager {
11. // 连接池存放
12. public Hashtable<String,IConnectionPool> pools = new Hashtable<String, IConnectionPool>();
13. // 初始化
14. private ConnectionPoolManager(){
15. init();
16. }
17. // 单例实现
18. public static ConnectionPoolManager getInstance(){
19. return Singtonle.instance;
20. }
21. private static class Singtonle {
22. private static ConnectionPoolManager instance =  new ConnectionPoolManager();
23. }
24. // 初始化所有的连接池
25. public void init(){
26. for(int i =;i<DBInitInfo.beans.size();i++){
27. DBbean bean = DBInitInfo.beans.get(i);
28. ConnectionPool pool = new ConnectionPool(bean);
29. if(pool != null){
30. pools.put(bean.getPoolName(), pool);
31. System.out.println("Info:Init connection successed ->" +bean.getPoolName());
32. }
33. }
34. }
35. // 获得连接,根据连接池名字 获得连接
36. public Connection  getConnection(String poolName){
37. Connection conn = null;
38. if(pools.size()> && pools.containsKey(poolName)){
39. conn = getPool(poolName).getConnection();
40. }else{
41. System.out.println("Error:Can't find this connecion pool ->"+poolName);
42. }
43. return conn;
44. }
45. // 关闭，回收连接
46. public void close(String poolName,Connection conn){
47. IConnectionPool pool = getPool(poolName);
48. try {
49. if(pool != null){
50. pool.releaseConn(conn);
51. }
52. } catch (SQLException e) {
53. System.out.println("连接池已经销毁");
54. e.printStackTrace();
55. }
56. }
57. // 清空连接池
58. public void destroy(String poolName){
59. IConnectionPool pool = getPool(poolName);
60. if(pool != null){
61. pool.destroy();
62. }
63. }
64. // 获得连接池
65. public IConnectionPool getPool(String poolName){
66. IConnectionPool pool = null;
67. if(pools.size() > ){
68. pool = pools.get(poolName);
69. }
70. return pool;
71. }
72. }

package pool;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Hashtable;
/**
 * 连接管理类
 * @author Ran
 *
 */
public class ConnectionPoolManager {

	// 连接池存放
	public Hashtable<String,IConnectionPool> pools = new Hashtable<String, IConnectionPool>();

	// 初始化
	private ConnectionPoolManager(){
		init();
	}
	// 单例实现
	public static ConnectionPoolManager getInstance(){
		return Singtonle.instance;
	}
	private static class Singtonle {
		private static ConnectionPoolManager instance =  new ConnectionPoolManager();
	}

	// 初始化所有的连接池
	public void init(){
		for(int i =0;i<DBInitInfo.beans.size();i++){
			DBbean bean = DBInitInfo.beans.get(i);
			ConnectionPool pool = new ConnectionPool(bean);
			if(pool != null){
				pools.put(bean.getPoolName(), pool);
				System.out.println("Info:Init connection successed ->" +bean.getPoolName());
			}
		}
	}

	// 获得连接,根据连接池名字 获得连接
	public Connection  getConnection(String poolName){
		Connection conn = null;
		if(pools.size()>0 && pools.containsKey(poolName)){
			conn = getPool(poolName).getConnection();
		}else{
			System.out.println("Error:Can't find this connecion pool ->"+poolName);
		}
		return conn;
	}

	// 关闭，回收连接
	public void close(String poolName,Connection conn){
			IConnectionPool pool = getPool(poolName);
			try {
				if(pool != null){
					pool.releaseConn(conn);
				}
			} catch (SQLException e) {
				System.out.println("连接池已经销毁");
				e.printStackTrace();
			}
	}

	// 清空连接池
	public void destroy(String poolName){
		IConnectionPool pool = getPool(poolName);
		if(pool != null){
			pool.destroy();
		}
	}

	// 获得连接池
	public IConnectionPool getPool(String poolName){
		IConnectionPool pool = null;
		if(pools.size() > 0){
			 pool = pools.get(poolName);
		}
		return pool;
	}
}

1. package pool;
2. import java.util.ArrayList;
3. import java.util.List;
4. /**
5. * 初始化，模拟加载所有的配置文件
6. * @author Ran
7. *
8. */
9. public class DBInitInfo {
10. public  static List<DBbean>  beans = null;
11. static{
12. beans = new ArrayList<DBbean>();
13. // 这里数据 可以从xml 等配置文件进行获取
14. // 为了测试，这里我直接写死
15. DBbean beanOracle = new DBbean();
16. beanOracle.setDriverName("oracle.jdbc.driver.OracleDriver");
17. beanOracle.setUrl("jdbc:oracle:thin:@7MEXGLUY95W1Y56:1521:orcl");
18. beanOracle.setUserName("mmsoa");
19. beanOracle.setPassword("password1234");
20. beanOracle.setMinConnections();
21. beanOracle.setMaxConnections();
22. beanOracle.setPoolName("testPool");
23. beans.add(beanOracle);
24. }
25. }

package pool;

import java.util.ArrayList;
import java.util.List;
/**
 * 初始化，模拟加载所有的配置文件
 * @author Ran
 *
 */
public class DBInitInfo {
	public  static List<DBbean>  beans = null;
	static{
		beans = new ArrayList<DBbean>();
		// 这里数据 可以从xml 等配置文件进行获取
		// 为了测试，这里我直接写死
		DBbean beanOracle = new DBbean();
		beanOracle.setDriverName("oracle.jdbc.driver.OracleDriver");
		beanOracle.setUrl("jdbc:oracle:thin:@7MEXGLUY95W1Y56:1521:orcl");
		beanOracle.setUserName("mmsoa");
		beanOracle.setPassword("password1234");

		beanOracle.setMinConnections(5);
		beanOracle.setMaxConnections(100);

		beanOracle.setPoolName("testPool");
		beans.add(beanOracle);
	}
}

测试：

1. package pool;
2. import java.sql.Connection;
3. /**
4. * 模拟线程启动，去获得连接
5. * @author Ran
6. *
7. */
8. public class ThreadConnection implements Runnable{
9. private IConnectionPool pool;
10. @Override
11. public void run() {
12. pool = ConnectionPoolManager.getInstance().getPool("testPool");
13. }
14. public Connection getConnection(){
15. Connection conn = null;
16. if(pool != null && pool.isActive()){
17. conn = pool.getConnection();
18. }
19. return conn;
20. }
21. public Connection getCurrentConnection(){
22. Connection conn = null;
23. if(pool != null && pool.isActive()){
24. conn = pool.getCurrentConnecton();
25. }
26. return conn;
27. }
28. }

package pool;

import java.sql.Connection;
/**
 * 模拟线程启动，去获得连接
 * @author Ran
 *
 */
public class ThreadConnection implements Runnable{
	private IConnectionPool pool;
	@Override
	public void run() {
		pool = ConnectionPoolManager.getInstance().getPool("testPool");
	}

	public Connection getConnection(){
		Connection conn = null;
		if(pool != null && pool.isActive()){
			conn = pool.getConnection();
		}
		return conn;
	}

	public Connection getCurrentConnection(){
		Connection conn = null;
		if(pool != null && pool.isActive()){
			conn = pool.getCurrentConnecton();
		}
		return conn;
	}
}

1. package pool;
2. public class Client {
3. public static void main(String[] args) throws InterruptedException {
4. // 初始化连接池
5. Thread t = init();
6. t.start();
7. t.join();
8. ThreadConnection a = new ThreadConnection();
9. ThreadConnection b = new ThreadConnection();
10. ThreadConnection c = new ThreadConnection();
11. Thread t1 = new Thread(a);
12. Thread t2 = new Thread(b);
13. Thread t3 = new Thread(c);
14. // 设置优先级，先让初始化执行，模拟 线程池 先启动
15. // 这里仅仅表面控制了，因为即使t 线程先启动，也不能保证pool 初始化完成，为了简单模拟，这里先这样写了
16. t1.setPriority();
17. t2.setPriority();
18. t3.setPriority();
19. t1.start();
20. t2.start();
21. t3.start();
22. System.out.println("线程A-> "+a.getConnection());
23. System.out.println("线程B-> "+b.getConnection());
24. System.out.println("线程C-> "+c.getConnection());
25. }
26. // 初始化
27. public static Thread init() {
28. Thread t = new Thread(new Runnable() {
29. @Override
30. public void run() {
31. IConnectionPool  pool = initPool();
32. while(pool == null || !pool.isActive()){
33. pool = initPool();
34. }
35. }
36. });
37. return t;
38. }
39. public static IConnectionPool initPool(){
40. return ConnectionPoolManager.getInstance().getPool("testPool");
41. }
42. }

package pool;

public class Client {
	public static void main(String[] args) throws InterruptedException {
		// 初始化连接池
		Thread t = init();
		t.start();
		t.join();

		ThreadConnection a = new ThreadConnection();
		ThreadConnection b = new ThreadConnection();
		ThreadConnection c = new ThreadConnection();
		Thread t1 = new Thread(a);
		Thread t2 = new Thread(b);
		Thread t3 = new Thread(c);

		// 设置优先级，先让初始化执行，模拟 线程池 先启动
		// 这里仅仅表面控制了，因为即使t 线程先启动，也不能保证pool 初始化完成，为了简单模拟，这里先这样写了
		t1.setPriority(10);
		t2.setPriority(10);
		t3.setPriority(10);
		t1.start();
		t2.start();
		t3.start();

		System.out.println("线程A-> "+a.getConnection());
		System.out.println("线程B-> "+b.getConnection());
		System.out.println("线程C-> "+c.getConnection());
	}

	// 初始化
	public static Thread init() {
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				IConnectionPool  pool = initPool();
				while(pool == null || !pool.isActive()){
					pool = initPool();
				}
			}
		});
		return t;
	}

	public static IConnectionPool initPool(){
		return ConnectionPoolManager.getInstance().getPool("testPool");
	}

}

小结 ：

1.连接池诞生原因是，如果每次都从数据库获得连接，时间比较长，因此我们提前做建立一些连接，放在连接池里面，每次都从里面取

2.上面仅仅写了连接池基本原理，关于多线程下连接池的管理没写，后面对多线程操作熟练了添加吧