一、為什麽在連接數據庫時要使用連接池

數據庫連接是一種關鍵的有限的昂貴的資源，這一點在多用戶的網頁應用程序中體現得尤為突出。 一個數據庫連接對象均對應一個物理數據庫連接，每次操作都打開一個物理連接，使用完都關閉連接，這樣造成系統的 性能低下。 數據庫連接池的解決方案是在應用程序啟動時建立足夠的數據庫連接，並講這些連接組成一個連接池(簡單說：在一個“池”裏放了好多半成品的數據庫聯接對象)，由應用程序動態地對池中的連接進行申請、使用和釋放。對於多於連接池中連接數的並發請求，應該在請求隊列中排隊等待。並且應用程序可以根據池中連接的使用率，動態增加或減少池中的連接數。 連接池技術盡可能多地重用了消耗內存地資源，大大節省了內存，提高了服務器地服務效率，能夠支持更多的客戶服務。通過使用連接池，將大大提高程序運行效率，同時，我們可以通過其自身的管理機制來監視數據庫連接的數量、使用情況等。

二、數據庫連接池的基本原理

數據庫連接池的基本思想就是為數據庫連接 建立一個“緩沖池”。預先在緩沖池中放入一定數量的連接，當需要建立數據庫連接時，只需從“緩沖池”中取出一個，使用完畢之後再放回去。我們可以通過設定 連接池最大連接數來防止系統無盡的與數據庫連接。更為重要的是我們可以通過連接池的管理機制監視數據庫的連接的數量?使用情況，為系統開發?測試及性能調 整提供依據。

三、數據庫連接池的工作原理

連接池的工作原理主要由三部分組成，分別為連接池的建立、連接池中連接的使用管理、連接池的關閉。

第一、連接池的建立。一般在系統初始化時，連接池會根據系統配置建立，並在池中創建了幾個連接對象，以便使用時能從連接池中獲取。連接池中的連接不能隨意創建和關閉，這樣避免了連接隨意建立和關閉造成的系統開銷。Java中提供了很多容器類可以方便的構建連接池，例如Vector、Stack等。

第二、連接池的管理。連接池管理策略是連接池機制的核心，連接池內連接的分配和釋放對系統的性能有很大的影響。其管理策略是：

當客戶請求數據庫連接時，首先查看連接池中是否有空閑連接，如果存在空閑連接，則將連接分配給客戶使用；如果沒有空閑連接，則查看當前所開的連接數是否已經達到最大連接數，如果沒達到就重新創建一個連接給請求的客戶；如果達到就按設定的最大等待時間進行等待，如果超出最大等待時間，則拋出異常給客戶。

當客戶釋放數據庫連接時，先判斷該連接的引用次數是否超過了規定值，如果超過就從連接池中刪除該連接，否則保留為其他客戶服務。

該策略保證了數據庫連接的有效復用，避免頻繁的建立、釋放連接所帶來的系統資源開銷。

第三、連接池的關閉。當應用程序退出時，關閉連接池中所有的連接，釋放連接池相關的資源，該過程正好與創建相反。

四、連接池關鍵問題分析

　　1、並發問題

　　為了使連接管理服務具有最大的通用性，必須考慮多線程環境，即並發問題。這個問題相對比較好解決，因為Java語言自身提供了對並發管理的支 持，使用synchronized關鍵字即可確保線程是同步的。使用方法為直接在類方法前面加上synchronized關鍵字，如：

　　public synchronized Connection getConnection()

　　2、多數據庫服務器和多用戶

　　對於大型的企業級應用，常常需要同時連接不同的數據庫(如連接Oracle和Sybase)。如何連接不同的數據庫呢?我們采用的策略是：設計 一個符合單例模式的連接池管理類，在連接池管理類的唯一實例被創建時讀取一個資源文件，其中資源文件中存放著多個數據庫的url地址()?用戶名()?密 碼()等信息。如 tx.url=172.21.15.123：5000/tx_it，tx.user=yang，tx.password=yang321。根據資源文件提 供的信息，創建多個連接池類的實例，每一個實例都是一個特定數據庫的連接池。連接池管理類實例為每個連接池實例取一個名字，通過不同的名字來管理不同的連 接池。

　　對於同一個數據庫有多個用戶使用不同的名稱和密碼訪問的情況，也可以通過資源文件處理，即在資源文件中設置多個具有相同url地址，但具有不同用戶名和密碼的數據庫連接信息。

　　3、事務處理

　　我們知道，事務具有原子性，此時要求對數據庫的操作符合“ALL-ALL-NOTHING”原則,即對於一組SQL語句要麽全做，要麽全不做。

　　在Java語言中，Connection類本身提供了對事務的支持，可以通過設置Connection的AutoCommit屬性為 false,然後顯式的調用commit或rollback方法來實現。但要高效的進行Connection復用，就必須提供相應的事務支持機制。可采用 每一個事務獨占一個連接來實現，這種方法可以大大降低事務管理的復雜性。

　　4、連接池的分配與釋放

　　連接池的分配與釋放，對系統的性能有很大的影響。合理的分配與釋放，可以提高連接的復用度，從而降低建立新連接的開銷，同時還可以加快用戶的訪問速度。

　　對於連接的管理可使用空閑池。即把已經創建但尚未分配出去的連接按創建時間存放到一個空閑池中。每當用戶請求一個連接時，系統首先檢查空閑池內 有沒有空閑連接。如果有就把建立時間最長(通過容器的順序存放實現)的那個連接分配給他(實際是先做連接是否有效的判斷，如果可用就分配給用戶，如不可用 就把這個連接從空閑池刪掉，重新檢測空閑池是否還有連接);如果沒有則檢查當前所開連接池是否達到連接池所允許的最大連接數(maxConn),如果沒有 達到，就新建一個連接，如果已經達到，就等待一定的時間(timeout)。如果在等待的時間內有連接被釋放出來就可以把這個連接分配給等待的用戶，如果 等待時間超過預定時間timeout,則返回空值(null)。系統對已經分配出去正在使用的連接只做計數，當使用完後再返還給空閑池。對於空閑連接的狀 態，可開辟專門的線程定時檢測，這樣會花費一定的系統開銷，但可以保證較快的響應速度。也可采取不開辟專門線程，只是在分配前檢測的方法。

　　5、連接池的配置與維護

　　連接池中到底應該放置多少連接，才能使系統的性能最佳?系統可采取設置最小連接數(minConn)和最大連接數(maxConn)來控制連接 池中的連接。最小連接數是系統啟動時連接池所創建的連接數。如果創建過多，則系統啟動就慢，但創建後系統的響應速度會很快;如果創建過少，則系統啟動的很 快，響應起來卻慢。這樣，可以在開發時，設置較小的最小連接數，開發起來會快，而在系統實際使用時設置較大的，因為這樣對訪問客戶來說速度會快些。最大連 接數是連接池中允許連接的最大數目，具體設置多少，要看系統的訪問量，可通過反復測試，找到最佳點。

　　如何確保連接池中的最小連接數呢?有動態和靜態兩種策略。動態即每隔一定時間就對連接池進行檢測，如果發現連接數量小於最小連接數，則補充相應數量的新連接,以保證連接池的正常運轉。靜態是發現空閑連接不夠時再去檢查。

程序開發過程中，存在很多問題：

首先，每一次web請求都要建立一次數據庫連接。建立連接是一個費時的活動，每次都得花費0.05s～1s的時間，而且系統還要分配內存資源。這個時間對於一次或幾次數據庫操作，或許感覺不出系統有多大的開銷。

可是對於現在的web應用，尤其是大型電子商務網站，同時有幾百人甚至幾千人在線是很正常的事。在這種情況下，頻繁的進行數據庫連接操作勢必占用很多的系統資源，網站的響應速度必定下降，嚴重的甚至會造成服務器的崩潰。不是危言聳聽，這就是制約某些電子商務網站發展的技術瓶頸問題。其次，對於每一次數據庫連接，使用完後都得斷開。否則，如果程序出現異常而未能關閉，將會導致數據庫系統中的內存泄漏，最終將不得不重啟數據庫

通過上面的分析，我們可以看出來，“數據庫連接”是一種稀缺的資源，為了保障網站的正常使用，應該對其進行妥善管理。其實我們查詢完數據庫後，如果不關閉連接，而是暫時存放起來，當別人使用時，把這個連接給他們使用。就避免了一次建立數據庫連接和斷開的操作時間消耗。

數據庫連接池的基本思想：就是為數據庫連接建立一個“緩沖池”。預先在緩沖池中放入一定數量的連接，當需要建立數據庫連接時，只需從“緩沖池”中取出一個，使用完畢之後再放回去。我們可以通過設定連接池最大連接數來防止系統無盡的與數據庫連接

創建數據庫連接池大概有3個步驟：

① 創建ConnectionPool實例，並初始化創建10個連接，保存在Vector中（線程安全）
② 實現getConnection()從連接庫中獲取一個可用的連接
③ returnConnection(conn) 提供將連接放回連接池中方法

五、連接池實現代碼（java）

1. package book.util;
2. import java.sql.Connection;
3. import java.sql.DatabaseMetaData;
4. import java.sql.Date;
5. import java.sql.Driver;
6. import java.sql.DriverManager;
7. import java.sql.PreparedStatement;
8. import java.sql.ResultSet;
9. import java.sql.SQLException;
10. import java.sql.Statement;
11. import java.util.Vector;
12. public class Pool {
13. public static void main(String[] args) {
14. Pool pool = new Pool("com.microsoft.sqlserver.jdbc.SQLServerDriver","jdbc:sqlserver://localhost:1433;DataBaseName=Book","sa","aaaaaa");
15. try {
16. pool.createConnections(4);
18. } catch (SQLException e) {
19. e.printStackTrace();
20. }
21. Connection conn = pool.getConnection();
22. try {
23. String sql = "select * from allbook";
24. PreparedStatement ps;
25. ps = conn.prepareStatement(sql);
26. ResultSet rs=ps.executeQuery();
27. while(rs.next()){
28. System.out.println(rs.getString("BOOKNAME"));
29. }
30. } catch (SQLException e) {
31. // TODO Auto-generated catch block
32. e.printStackTrace();
33. }finally{
34. pool.returnConnection(conn);
35. }
36. //long startTime=System.currentTimeMillis();
37. //long endTime=System.currentTimeMillis();
38. //System.out.println("程序運行時間： "+(endTime-startTime)+"ms");
39. }
41. private String jdbcDriver = "";//數據庫驅動
42. private String dbUrl = "";//數據庫url
43. private String dbUsername = "";//數據庫用戶名
44. private String dbPassword = "";//數據庫密碼
45. private String testTable = "";
46. private int initialConnectionsNum = 10;//連接池初始連接數
47. private int maxConnectionsNum = 50;//連接池最大連接數
48. private int incrementalConnections = 5;//每次動態添加的連接數
49. private Vector<PooledConnection> connections = null;//向量，存放連接池中的連接，初始為空
51. /*無參構造函數*/
52. public Pool()
53. {}
55. /*帶參數的構造函數
56. * 初始化數據庫驅動、數據庫url、數據庫用戶名、數據庫密碼、測試表
57. * */
58. public Pool(String driver, String url, String name, String pass)
59. {
60. this.jdbcDriver = driver;
61. this.dbUrl = url;
62. this.dbUsername = name;
63. this.dbPassword = pass;
64. //this.testTable = table;
65. try {
66. this.createPool();
67. } catch (InstantiationException e) {
68. // TODO Auto-generated catch block
69. e.printStackTrace();
70. } catch (IllegalAccessException e) {
71. // TODO Auto-generated catch block
72. e.printStackTrace();
73. } catch (ClassNotFoundException e) {
74. // TODO Auto-generated catch block
75. e.printStackTrace();
76. } catch (SQLException e) {
77. // TODO Auto-generated catch block
78. e.printStackTrace();
79. }
80. }
82. /*函數，創建連接池*/
83. public synchronized void createPool()
84. throws InstantiationException, IllegalAccessException,
85. ClassNotFoundException, SQLException
86. {
87. /*確保連接池為創建，如果已經創建，則保存連接的向量不為空
88. * */
89. if (this.connections != null)
90. {
91. return ;
92. }
93. //驅動器實例化
94. Driver driver = (Driver)(Class.forName(this.jdbcDriver).newInstance());
95. //註冊驅動器
96. DriverManager.registerDriver(driver);
97. //創建保存連接的向量
98. this.connections = new Vector<PooledConnection>();
99. //創建數據庫連接
100. this.createConnections(this.initialConnectionsNum);
101. }
103. /*函數，創建數據庫連接
104. * */
105. private void createConnections (int num) throws SQLException
106. {
107. /*循環創建連接
108. * 需要首先檢查當前連接數是否已經超出連接池最大連接數
109. * */
110. for (int i = 0; i < num; ++i)
111. {
112. //檢查
113. if (this.connections.size() >= this.maxConnectionsNum)
114. {
115. return;
116. }
117. //創建連接
118. this.connections.addElement
119. (new PooledConnection(newConnection()));
120. }
122. }
124. /*函數,創建一個數據庫連接*/
125. private Connection newConnection() throws SQLException
126. {
127. /*創建連接*/
128. Connection con = DriverManager.getConnection(this.dbUrl,
129. this.dbUsername, this.dbPassword);
130. /*如果是第一次創建連接，則檢查所連接的數據庫的允許最大連接數是否小於
131. * 我們所設定的最大連接數*/
132. if (this.connections.size() == 0)
133. {
134. DatabaseMetaData metadata = con.getMetaData();
135. //得到數據庫最大連接數
136. int dbMaxConnectionsNum = metadata.getMaxConnections();
137. //如果數據庫最大連接數更小，則更改我們所設定的連接池最大連接數
138. if (dbMaxConnectionsNum > 0
139. && this.maxConnectionsNum > dbMaxConnectionsNum)
140. {
141. this.maxConnectionsNum = dbMaxConnectionsNum;
142. }
143. }
144. return con;
145. }
147. /*函數，得到一個可用連接
148. * */
149. public synchronized Connection getConnection ()
150. {
151. Connection con = null;
152. /*檢查連接池是否已經建立*/
153. if (this.connections == null)
154. {
155. return con;
156. }
157. //得到一個可用連接
158. try {
159. con = this.getFreeConnection();
160. } catch (SQLException e) {
161. // TODO Auto-generated catch block
162. e.printStackTrace();
163. }
164. //如果未找到合適連接，循環等待、查找，知道找到合適連接
165. while(con == null)
166. {
167. this.wait(30);
168. try {
169. con = this.getFreeConnection();
170. } catch (SQLException e) {
171. // TODO Auto-generated catch block
172. e.printStackTrace();
173. }
174. }
176. return con;
177. }
180. /*函數，得到一個可用連接*/
181. private Connection getFreeConnection() throws SQLException
182. {
183. Connection con = null;
184. //查找一個可用連接
185. con = this.findFreeConnection();
186. //如果未找到可用連接，就建立一些新的連接，再次查找
187. if (con == null)
188. {
189. this.createConnections(this.incrementalConnections);
190. //再次查找
191. con = this.findFreeConnection();
192. }
193. return con;
194. }
197. /*函數，從現有連接中查找一個可用連接
198. * 在現有的連接中（向量connections中）找到一個空閑連接，
199. * 並測試這個鏈接是否可用，若不可用則重新建立連接，替換原來的連接*/
200. private Connection findFreeConnection () throws SQLException
201. {
202. Connection con = null;
203. for (int i = 0; i < this.connections.size(); ++i)
204. {
205. PooledConnection pol = (PooledConnection)this.connections.get(i);
206. if (!pol.isBusy())
207. {
208. /*如果此鏈接未被使用，則返回這個連接並，設置正在使用標誌*/
209. con = pol.getCon();
210. pol.setBusy(true);
211. /*測試連接是否可用*/
212. if (!this.testCon(con))
213. {
214. con = this.newConnection();
215. pol.setCon(con);
216. }
217. break;
218. }
219. }
220. return con;
221. }
223. /*函數，測試連接是否可用
224. * */
225. private boolean testCon (Connection con)
226. {
227. boolean useable = true;
228. try
229. {
230. Statement st = con.createStatement();
231. ResultSet rs = st.executeQuery("select count(*) from " + this.testTable);
232. rs.next();
233. }
234. catch(SQLException e)
235. {
236. /*上面拋出異常，連接不可用，關閉*/
237. useable = false;
238. this.closeConnection(con);
239. }
240. return useable;
241. }
243. /*函數，將使用完畢的連接放回連接池中
244. * */
245. public void returnConnection(Connection con)
246. {
247. /*確保連接池存在*/
248. if (this.connections == null)
249. {
250. return ;
251. }
252. for (int i = 0; i < this.connections.size(); ++i)
253. {
254. PooledConnection pool = this.connections.get(i);
255. //找到相應連接，設置正在使用標誌為false
256. if (con == pool.getCon())
257. {
258. pool.setBusy(false);
259. }
260. }
262. }
264. /*函數，刷新連接池中的連接*/
265. public synchronized void refreshConneciontPool () throws SQLException
266. {
267. /*確保連接池存在*/
268. if (this.connections == null)
269. {
270. return ;
271. }
272. for (int i = 0; i < this.connections.size(); ++i)
273. {
274. PooledConnection pool = this.connections.get(i);
275. if (pool.isBusy())
276. {
277. this.wait(5000);
278. }
279. this.closeConnection(pool.getCon());
280. pool.setCon(this.newConnection());
281. pool.setBusy(false);
282. }
283. }
285. /*函數，關閉連接池*/
286. public void closeConnectionPool()
287. {
288. /*確保連接池存在*/
289. if (this.connections == null)
290. {
291. return ;
292. }
293. for (int i = 0; i < this.connections.size(); ++i)
294. {
295. PooledConnection pool = this.connections.get(i);
296. if (pool.isBusy())
297. {
298. this.wait(5000);
299. }
300. this.closeConnection(pool.getCon());
301. this.connections.remove(i);
302. }
303. this.connections = null;
304. }
306. /*函數，暫時無可用連接，進入等待隊列等待m秒，再試
307. * */
308. private void wait(int mSecond)
309. {
310. try {
311. Thread.sleep(mSecond);
312. } catch (InterruptedException e) {
313. // TODO Auto-generated catch block
314. e.printStackTrace();
315. }
316. }
318. /**
319. * @return the jdbcDriver
320. */
321. public String getJdbcDriver() {
322. return jdbcDriver;
323. }
325. /**
326. * @param jdbcDriver the jdbcDriver to set
327. */
328. public void setJdbcDriver(String jdbcDriver) {
329. this.jdbcDriver = jdbcDriver;
330. }
332. /**
333. * @return the dbUrl
334. */
335. public String getDbUrl() {
336. return dbUrl;
337. }
339. /**
340. * @param dbUrl the dbUrl to set
341. */
342. public void setDbUrl(String dbUrl) {
343. this.dbUrl = dbUrl;
344. }
346. /**
347. * @return the dbUsername
348. */
349. public String getDbUsername() {
350. return dbUsername;
351. }
353. /**
354. * @param dbUsername the dbUsername to set
355. */
356. public void setDbUsername(String dbUsername) {
357. this.dbUsername = dbUsername;
358. }
360. /**
361. * @return the dbPassword
362. */
363. public String getDbPassword() {
364. return dbPassword;
365. }
367. /**
368. * @param dbPassword the dbPassword to set
369. */
370. public void setDbPassword(String dbPassword) {
371. this.dbPassword = dbPassword;
372. }
374. /**
375. * @return the testTable
376. */
377. public String getTestTable() {
378. return testTable;
379. }
381. /**
382. * @param testTable the testTable to set
383. */
384. public void setTestTable(String testTable) {
385. this.testTable = testTable;
386. }
388. /**
389. * @return the initialConnectionsNum
390. */
391. public int getInitialConnectionsNum() {
392. return initialConnectionsNum;
393. }
395. /**
396. * @param initialConnectionsNum the initialConnectionsNum to set
397. */
398. public void setInitialConnectionsNum(int initialConnectionsNum) {
399. this.initialConnectionsNum = initialConnectionsNum;
400. }
402. /**
403. * @return the maxConnectionsNum
404. */
405. public int getMaxConnectionsNum() {
406. return maxConnectionsNum;
407. }
409. /**
410. * @param maxConnectionsNum the maxConnectionsNum to set
411. */
412. public void setMaxConnectionsNum(int maxConnectionsNum) {
413. this.maxConnectionsNum = maxConnectionsNum;
414. }
416. /**
417. * @return the incrementalConnections
418. */
419. public int getIncrementalConnections() {
420. return incrementalConnections;
421. }
423. /**
424. * @param incrementalConnections the incrementalConnections to set
425. */
426. public void setIncrementalConnections(int incrementalConnections) {
427. this.incrementalConnections = incrementalConnections;
428. }
430. /**
431. * @return the connections
432. */
433. public Vector<PooledConnection> getConnections() {
434. return connections;
435. }
437. /**
438. * @param connections the connections to set
439. */
440. public void setConnections(Vector<PooledConnection> connections) {
441. this.connections = connections;
442. }
444. /*函數，連接使用完畢，關閉連接*/
445. private void closeConnection (Connection con)
446. {
447. try
448. {
449. con.close();
450. }
451. catch(SQLException e)
452. {
453. e.printStackTrace();
454. }
455. }
458. /*內部使用的保存數據庫連接的類
459. * 兩個成員變量：連接、是否正在使用*/
460. class PooledConnection
461. {
462. private Connection con = null;//連接
463. private boolean busy = false;//是否正在使用，默認為非
465. /*構造函數*/
466. public PooledConnection(Connection con)
467. {
468. this.con = con;
469. }
471. /**
472. * @return the con
473. */
474. public Connection getCon() {
475. return con;
476. }
478. /**
479. * @param con the con to set
480. */
481. public void setCon(Connection con) {
482. this.con = con;
483. }
485. /**
486. * @return the busy
487. */
488. public boolean isBusy() {
489. return busy;
490. }
492. /**
493. * @param busy the busy to set
494. */
495. public void setBusy(boolean busy) {
496. this.busy = busy;
497. }
498. }
500. }

數據庫連接池實現原理