1.连接池的介绍：

1.1应用背景：

一般的应用程序都会访问到数据库，在程序访问数据库的时候，每一次数据访问请求都必须经过下面几个步骤：建立数据库连接，打开数据库，对数据库中的数据进行操作，关闭数据库连接。而建立数据库连接和打开数据库是一件很消耗资源并且费时的工作，如果在系统中很频繁的发生这种数据库连接，必然会影响到系统的性能，甚至会导致系统的崩溃。

1.2技术思想：

在系统初始化阶段，建立一定数量的数据库连接对象(Connection)，并将其存储在连接池中定义的容器中。当有数据库访问请求时，就从连接池中的这个容器中拿出一个连接；当容器中的连接已经用完，并且还没有达到系统定义的最大连接数时，可以再创建一个新的连接，当当前使用的连接数达到最大连接数时，就要等待其他访问请求将连接放回容器后才能使用。当使用完连接的时候，必须将连接放回容器中，这样不同的数据库访问请求就可以共享这些连接，通过重复使用这些已经建立的数据库连接，可以解决上节中说到的频繁建立连接的缺点，从而提高了系统的性能。

经过上述描述，我们可以归纳出数据库连接池的主要操作：

(1)首先建立一个数据库连接池对象

(2)初始化一定数量的数据库连接，放入连接池对象的容器中

(3)当有数据库访问请求时，直接从连接池的容器中得到一个连接，这里出现三种情况：

(a)当容器中的还有连接时，则返回给数据库访问请求者一个连接

(b)当容器中没有连接时，并且当前建立的连接数没有达到系统定义的最大连接数，则创建一个新的数据库连接。

(c)当容器中的没有连接并且当前建立的连接数达到系统定义的最大连接数，则当前访问数据库请求就要等待其他访问请求释放连接。

(4)当数据库访问完成后，应该将连接放回连接池的容器中。

(5)当服务停止时，需要先释放数据库连接池中的所有数据库连接，然后再释放数据库连接池对象。

2.编程实现：

头文件(connection_pool.h)：

[cpp]   view plain  copy
  1. /*  
  2.  *File: connection_pool.h  
  3.  *Author: fengwei  
  4.  */    
  5.      
  6. #ifndef _CONNECTION_POOL_H    
  7. #define _CONNECTION_POOL_H    
  8.      
  9. #include <mysql_connection.h>    
  10. #include <mysql_driver.h>    
  11. #include <cppconn/exception.h>    
  12. #include <cppconn/driver.h>    
  13. #include <cppconn/connection.h>    
  14. #include <cppconn/resultset.h>    
  15. #include <cppconn/prepared_statement.h>    
  16. #include <cppconn/statement.h>    
  17. #include <pthread.h>    
  18. #include <list>    
  19.      
  20. using namespace std;    
  21. using namespace sql;    
  22.      
  23. class ConnPool {    
  24. private:    
  25.     int curSize; //当前已建立的数据库连接数量    
  26.     int maxSize; //连接池中定义的最大数据库连接数    
  27.     string username;    
  28.     string password;    
  29.     string url;    
  30.     list<Connection*> connList; //连接池的容器队列  STL list 双向链表  
  31.     pthread_mutex_t lock; //线程锁    
  32.     static ConnPool *connPool;    
  33.     Driver*driver;    
  34.      
  35.     Connection*CreateConnection(); //创建一个连接    
  36.     void InitConnection(int iInitialSize); //初始化数据库连接池    
  37.     void DestoryConnection(Connection *conn); //销毁数据库连接对象    
  38.     void DestoryConnPool(); //销毁数据库连接池    
  39.     ConnPool(string url, string user, string password, int maxSize); //构造方法    
  40. public:    
  41.     ~ConnPool();    
  42.     Connection*GetConnection(); //获得数据库连接    
  43.     void ReleaseConnection(Connection *conn); //将数据库连接放回到连接池的容器中    
  44.     static ConnPool *GetInstance(); //获取数据库连接池对象    
  45. };    
  46. #endif  /*_CONNECTION_POOL_H */    

头文件中定义了一个容器connList,里面存放了很多个未使用的连接；在对容器内的连接进行操作的时候，需要加锁来保证程序的安全性，所以头文件中定义了一个lock，通过使用lock保证了同一时间只有一个线程对容器进行操作。

连接池类要统一管理整个应用程序中的连接，所以在整个系统中只需要维护一个连接池对象，试想：如果系统中定义了多个连接池对象，那么每一个对象都可以建立maxSize个连接，这样就失去了创建连接池的初衷，破环了通过连接池统一管理系统中连接的思想。所以这里使用单例模式编写连接池类，单例模式确保一个类只有一个实例，自己进行实例化并且向整个系统提供这个实例。

饿汉实现

为什么我不讲“线程安全的饿汉实现”？因为饿汉实现本来就是线程安全的，不用加锁。为啥？自己想！

[cpp]   view plain  copy
  1. class singleton  
  2. {  
  3. protected:  
  4.   singleton()  
  5.   {}  
  6. private:  
  7.   static singleton* p;  
  8. public:  
  9.   static singleton* initance();  
  10. };  
  11. singleton* singleton::p = new singleton;  
  12. singleton* singleton::initance()  
  13. {  
  14.   return p;  
  15. }  
在头文件中，我们定义了一个 静态的连接池对象connPool ， 连接池类提供一个静态的公共方法 GetInstance(), 外部程序通过调用这个方法来获得连接池对象。并且将连接池类的构造函数定义为私有的，外部的应用程序不能够通过new 来实例化连接池类，只能通过GetInstance() 方法获得连接池对象；在GetInstance() 方法中需要判断连接池类中定义的 connPool 是否为NULL ，若为NULL 则调用私有构造函数实例化connPool ，若不为空，则直接返回connPool 。这样就实现了连接池类的单例模式，从而保证了系统运行过程中只建立一个连接池类的实例对象。

在实例化连接池类的对象时，要对连接池做一些初始化的操作，即建立一定数量的数据库连接。程序中通过InitConnection(intiInitialSize)方法对连接池进行初始化，创建iInitialSize个连接，并且将这些连接放在连接池中的容器connList中，每新建一个连接，curSize就加1。当有数据库访问请求时，需要从连接池中获取一个连接，通过GetConnection()方法实现：首先判断容器中是否还有连接，如果有，则拿出容器中的第一个连接，并且将该连接移出容器；获得的连接要进行判断，如果连接已经关闭，则回收该连接的内存空间，并且重新创建一个连接；然后判断新创建的连接是否为空，如果为空，则说明当前已经建立连接的数量并不是curSize个，而是(curSize-1)个(应该除去这个空连接)。如果容器中已经没有连接了，则要判断当前的curSize值是否已经达到规定的maxSize，如果没有小于maxSize，将建立一个新的连接(++curSize)。如果超过maxSize则等待其他数据库访问请求释放数据库连接。

连接使用完以后，需要将连接放回连接池中，通过ReleaseConnection(sql::Connection* conn)方法实现，它的实现非常简单，就是将传进来的connection连接添加到连接池的容器中。

当需要回收连接池的内存空间时，需要先回收连接池中所有连接的内存空间，然后再释放连接池对象的内存空间。

实现数据库连接池主要的步骤就是上述这些，具体的代码实现如下所示(connection_pool.cpp)：

[cpp]   view plain  copy
  1. /*  
  2.  * connection_pool.cpp  
  3.  *  
  4.  */    
  5.      
  6. #include <stdexcept>    
  7. #include <exception>    
  8. #include <stdio.h>    
  9. #include "connection_pool.h"    
  10.      
  11. using namespace std;    
  12. using namespace sql;    
  13.      
  14. ConnPool *ConnPool::connPool = new ConnPool("tcp://127.0.0.1:3306", "root", "123456", 50);     
  15.      
  16. //连接池的构造函数    
  17. ConnPool::ConnPool(string url, string userName, string password, int maxSize) {    
  18.     this->maxSize = maxSize;    
  19.     this->curSize = 0;    
  20.     this->username = userName;    
  21.     this->password = password;    
  22.     this->url = url;    
  23.     try {    
  24.         this->driver = sql::mysql::get_driver_instance();    
  25.     } catch (sql::SQLException&e) {    
  26.         perror("驱动连接出错;\n");    
  27.     } catch (std::runtime_error&e) {    
  28.         perror("运行出错了\n");    
  29.     }    
  30.     this->InitConnection(maxSize / 2);    
  31. }    
  32.      
  33. //获取连接池对象，单例模式    
  34. ConnPool*ConnPool::GetInstance() {    
  35.     return connPool;    
  36. }    
  37.      
  38. //初始化连接池，创建最大连接数的一半连接数量    
  39. void ConnPool::InitConnection(int iInitialSize) {    
  40.     Connection*conn;    
  41.     pthread_mutex_lock(&lock);    
  42.     for (int i = 0; i < iInitialSize; i++) {    
  43.         conn = this->CreateConnection();    
  44.         if (conn) {    
  45.             connList.push_back(conn);    
  46.             ++(this->curSize);    
  47.         } else {    
  48.             perror("创建CONNECTION出错");    
  49.         }    
  50.     }    
  51.     pthread_mutex_unlock(&lock);    
  52. }    
  53.      
  54. //创建连接,返回一个Connection    
  55. Connection* ConnPool::CreateConnection() {    
  56.     Connection*conn;    
  57.     try {    
  58.         conn = driver->connect(this->url, this->username, this->password); //建立连接    
  59.         return conn;    
  60.     } catch (sql::SQLException&e) {    
  61.         perror("创建连接出错");    
  62.         return NULL;    
  63.     } catch (std::runtime_error&e) {    
  64.         perror("运行时出错");    
  65.         return NULL;    
  66.     }    
  67. }    
  68.      
  69. //在连接池中获得一个连接    
  70. Connection*ConnPool::GetConnection() {    
  71.     Connection*con;    
  72.     pthread_mutex_lock(&lock);    
  73.      
  74.     if (connList.size() > 0) {   //连接池容器中还有连接    
  75.         con = connList.front(); //得到第一个连接    
  76.         connList.pop_front();   //移除第一个连接    
  77.         if (con->isClosed()) {   //如果连接已经被关闭，删除后重新建立一个    
  78.             delete con;    
  79.             con = this->CreateConnection();    
  80.         }    
  81.         //如果连接为空，则创建连接出错    
  82.         if (con == NULL) {    
  83.             --curSize;    
  84.         }    
  85.         pthread_mutex_unlock(&lock);    
  86.         return con;    
  87.     } else {    
  88.         if (curSize < maxSize) { //还可以创建新的连接    
  89.             con = this->CreateConnection();    
  90.             if (con) {    
  91.                 ++curSize;    
  92.                 pthread_mutex_unlock(&lock);    
  93.                 return con;    
  94.             } else {    
  95.                 pthread_mutex_unlock(&lock);    
  96.                 return NULL;    
  97.             }    
  98.         } else { //建立的连接数已经达到maxSize    
  99.             pthread_mutex_unlock(&lock);    
  100.             return NULL;    
  101.         }    
  102.     }    
  103. }    
  104.      
  105. //回收数据库连接    
  106. void ConnPool::ReleaseConnection(sql::Connection * conn) {    
  107.     if (conn) {    
  108.         pthread_mutex_lock(&lock);    
  109.         connList.push_back(conn);    
  110.         pthread_mutex_unlock(&lock);    
  111.     }    
  112. }    
  113.      
  114. //连接池的析构函数    
  115. ConnPool::~ConnPool() {    
  116.     this->DestoryConnPool();    
  117. }    
  118.      
  119. //销毁连接池,首先要先销毁连接池的中连接    
  120. void ConnPool::DestoryConnPool() {    
  121.     list<Connection*>::iterator icon;    
  122.     pthread_mutex_lock(&lock);    
  123.     for (icon = connList.begin(); icon != connList.end(); ++icon) {    
  124.         this->DestoryConnection(*icon); //销毁连接池中的连接    
  125.     }    
  126.     curSize = 0;    
  127.     connList.clear(); //清空连接池中的连接    
  128.     pthread_mutex_unlock(&lock);    
  129. }    
  130.      
  131. //销毁一个连接    
  132. void ConnPool::DestoryConnection(Connection* conn) {    
  133.     if (conn) {    
  134.         try {    
  135.             conn->close();    
  136.         } catch (sql::SQLException&e) {    
  137.             perror(e.what());    
  138.         } catch (std::exception&e) {    
  139.             perror(e.what());    
  140.         }    
  141.         delete conn;    
  142.     }    
  143. }    

main.cpp

[cpp]   view plain  copy
  1. /*  
  2.  * main.cpp  
  3.  *  
  4.  */    
  5.      
  6. #include "connection_pool.h"    
  7.      
  8. namespace ConnectMySQL {    
  9.      
  10. //初始化连接池    
  11. ConnPool *connpool = ConnPool::GetInstance();    
  12.      
  13. void run() {    
  14.      
  15.     Connection *con;    
  16.     Statement *state;    
  17.     ResultSet *result;    
  18.      
  19.     // 从连接池中获取mysql连接    
  20.     con = connpool->GetConnection();    
  21.      
  22.     state = con->createStatement();    
  23.     state->execute("use holy");    
  24.      
  25.     // 查询    
  26.     result = state->executeQuery("select * from student where id < 1002");    
  27.      
  28.     // 输出查询    
  29.     while (result->next()) {    
  30.         int id = result->getInt("id");    
  31.         string name = result->getString("name");    
  32.         cout << id << " : " << name << endl;    
  33.     }    
  34.     delete state;    
  35.     connpool->ReleaseConnection(con);    
  36. }    
  37. }    
  38.      
  39. int main(int argc, char* argv[]) {    
  40.     ConnectMySQL::run();    
  41.     return 0;    
  1. }    

原文：http://blog.csdn.net/qq_29108585/article/details/78178232