基于C++“简单且有效”的“数据库连接池”

来自云龙湖轮廓分明的月亮  金牌会员 | 前天 17:36 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 837|帖子 837|积分 2521

前言


  • 数据库连接池在开发中应该是很常用的一个组件，他可以很好的节流连接数据库的时间开销；
  • 本文基使用C++实现了一个简单的数据库连接池，代码量只有400行只有，但是压力测试效果很好；
  • 欢迎收藏 + 关注，本人将会持续更新后端与AI算法有关知识点。

  
MySQL 数据库是基于 C/S 模式的，在每一次访问mysql服务器的时间，都必要创建一个TCP连接，但是，在高并发情况下，大量的 TCP 三次握手、MySQL Server 连接认证、MySQL Server 关闭连接接纳资源和 TCP 四次挥手所耗费的性能变乱也是很明显的，故设置连接池就是为了减少这一部分的性能损耗。
连接池功能点介绍

初始连接量

表示连接池事先会和 MySQL Serve r创建最小个数的连接，当应用发起 MySQL 访问时，不用再创建和 MySQL Server 新的连接，直接从连接池中获取一个可用的连接即可，使用完成后并不去释放连接，而是把连接再归还到连接池当中。
最大连接量

当并发访问MySQL Server的请求增多时，初始连接量已经不够用了，此时会去创建更多的连接给应用去使用，但是新创建的连接数量上限是maxSize，不能无限定的创建连接。而且当这些连接使用完之后，再次归还到连接池当中来维护。
最大空闲时间

当访问MySQL的并发请求多了以后，连接池里面的连接数量会动态增加，上限是maxSize 个，当这些连接用完会再次归还到连接池当中。如果在指定的时间内这些新增的连接都没有被再次使用过，那么新增加的这些连接资源就要被接纳掉，只必要保持初始连接量个连接即可。
连接超时时间

当MySQL的并发请求量过大，连接池中的连接数量已经到达最大数量了，而此时没有空闲的连接可供使用，那么此时应用从连接池获取连接无法乐成，它通过阻塞的方式获取连接的时间，如果超过一个时间，那么获取连接失败。
连接池主要包罗了以下功能点



  • 单例模式设置连接池；
  • 向用户提供一个接口，可以从池中拿到一个数据库连接；
  • 采用生产者-消费者模式，池用队列作为缓冲区，实现生成连接和拿取连接；
  • 采用锁，在创建、拿取连接中进行加锁；
  • 采用智能指针管理从队列中获取的连接，而且采用lambda实现智能指针的析构函数，将连接从新放回队列中；
  • 设置生产连接、接纳连接线程，而且驻留背景，作为守护线程；
  • 采用原子变量才记录当前池中的连接数。
创建目录如下：

代码

logger.h
  1. #ifndef PUBLIC_H_
  2. #define PUBLIC_H_
  4. #include <iostream>
  6. // 作用：封装简单的LOG
  7. #define LOGGER(str) std::cout << "====》" << __LINE__ << " time: " << __TIME__ << " message: " << str << std::endl;
  9. #endif // !PUBLIC_H_
复制代码
connection.h
  1. #ifndef CONNECTION_H_
  2. #define CONNECTION_H_
  4. #include <mysql/mysql.h>
  5. #include <ctime>
  6. #include <string>
  8. /*
  9. 功能：
  10.     初始化数据库连接
  11.     释放连接
  12.     连接数据库
  13.     查询mysql
  14.     修改数据库数据
  15.     刷新/设置空闲时间的起始时间点
  16.     返回空闲时间
  17. */
  19. class Connection
  20. {
  21. public:
  22.     // 初始化数据库连接
  23.     Connection();
  24.     // 释放连接
  25.     ~Connection();
  26.     // 连接数据库
  27.     bool connectionSqlBase(std::string ip, unsigned int port, std::string user, std::string passward, std::string dbName);
  28.     // 查询mysql
  29.     MYSQL_RES* query(std::string sql);
  30.     // 修改数据库数据
  31.     bool modify(std::string sql);
  32.     // 刷新/设置空闲时间的起始时间点
  33.     void setStartActivateTime();
  34.     // 返回空闲时间
  35.     clock_t getActivateTime();
  36. private:
  37.     MYSQL* m_sqlConn{};   // 连接mysql服务器
  38.     clock_t m_activateTime;  // 记录空闲时间的起始点
  39. };
  41. #endif // !CONNECTION_H_
复制代码
connection.cpp
  1. #include "connection.h"
  2. #include "logger.h"
  4. // 初始化数据库连接
  5. Connection::Connection()
  6. {
  7.     m_sqlConn = mysql_init(nullptr);
  8.     if(m_sqlConn == nullptr) {
  9.         LOGGER("mysql init false !!!");
  10.         return;
  11.     }
  12. }
  13. // 释放连接
  14. Connection::~Connection()
  15. {
  16.     mysql_close(m_sqlConn);
  17. }
  18. // 连接数据库
  19. bool Connection::connectionSqlBase(std::string ip, unsigned int port, std::string user, std::string passward, std::string dbName)
  20. {
  21.     if(nullptr == mysql_real_connect(m_sqlConn, ip.c_str(), user.c_str(), passward.c_str(), dbName.c_str(), port, NULL, 0)) {
  22.         LOGGER("mysql connects error!!");
  23.         return false;
  24.     }
  25.     return true;
  26. }
  27. // 查询mysql
  28. MYSQL_RES* Connection::query(std::string sql)
  29. {
  30.     int res = mysql_query(m_sqlConn, sql.c_str());
  31.     if(0 != res) {
  32.         LOGGER("sql query false!!!");
  33.         return nullptr;
  34.     }
  35.     return mysql_use_result(m_sqlConn);
  36. }
  37. // 修改数据库数据
  38. bool Connection::modify(std::string sql)
  39. {
  40.     int res = mysql_query(m_sqlConn, sql.c_str());
  41.     if(0 != res) {
  42.         LOGGER("sql update/insert/select false!!!");
  43.         return false;
  44.     }
  45.     return true;
  46. }
  47. // 刷新/设置空闲时间的起始时间点
  48. void Connection::setStartActivateTime()
  49. {
  50.     m_activateTime = clock();
  51. }
  52. // 返回空闲时间
  53. clock_t Connection::getActivateTime()
  54. {
  55.     return clock() - m_activateTime;
  56. }
复制代码
dbConnectionPool.h
  1. #ifndef DBCONNECTION_H_
  2. #define DBCONNECTION_H_
  4. #include "connection.h"
  5. #include <mysql/mysql.h>
  6. #include <queue>
  7. #include <string>
  8. #include <condition_variable>
  9. #include <atomic>
  10. #include <memory>
  12. // 核心：生产者、消费者模式
  14. class DbConnPool
  15. {
  16. public:
  17.     // 单例模式
  18.     static DbConnPool* getDbConnPool();
  19.     // 对外提供接口: 获取连接的数据库，通过智能指针回收
  20.     std::shared_ptr<Connection> getMysqlConn();
  21.    
  22.     // 测试
  23.     // void test()
  24.     // {
  25.     //     readConfigurationFile();
  26.     // }
  28. private:
  29.     // 单例模型：构造函数私有化, 目的：创建最小连接数量
  30.     DbConnPool();
  31.     DbConnPool(const DbConnPool&) = delete;
  32.     DbConnPool operator=(const DbConnPool&) = delete;
  33.    
  34.     // 读取配置文件
  35.     bool readConfigurationFile();
  37.     // 如果没有Mysql连接了，则产生新连接，这个线程驻留后台(像守护线程一样)
  38.     void produceNewConn();
  40.     // 如果队列线程 > initSize， 且空闲时间大于最大空闲时间，则回收
  41.     void recycleConn();
  43. private:
  44.     // MYSQL连接信息
  45.     std::string m_ip;
  46.     unsigned int m_port;
  47.     std::string m_username;
  48.     std::string m_password;
  49.     std::string m_dbname;
  51.     // 数据库连接池信息
  52.     int m_initSize;
  53.     int m_maxSize;
  54.     int m_maxFreeTime;
  55.     int m_maxConnTime;
  57.     // 生产者、消费者共享内存：获取连接
  58.     std::queue<Connection*> m_connQueue;
  59.     // 存储当前存储到队列中存储的数量
  60.     std::atomic_int m_conntionCnt{};
  62.     // 锁
  63.     std::mutex m_queueMuetx;
  65.     // 生产者、消费者：产生连接和取连接
  66.     std::condition_variable m_cv;  // 用于生产线程和消费线程之间的通信
  67. };
  69. #endif // !DBCONNECTION_H_
复制代码
dbConnectionPool.cpp
  1. #include "dbConnectionPool.h"
  2. #include "connection.h"
  3. #include "logger.h"
  5. #include <iostream>
  6. #include <cstdio>
  7. #include <cstring>
  8. #include <mutex>
  9. #include <thread>
  10. #include <functional>
  11. #include <chrono>
  13. // 创建连接：new，但是拿取连接后是交给shared_ptr
  15. // 单例模式
  16. DbConnPool* DbConnPool::getDbConnPool()
  17. {
  18.     // 最简单的方式：static
  19.     static DbConnPool pool;
  20.     return &pool;
  21. }
  23. // 对外提供接口: 获取连接的数据库，通过智能指针回收
  24. std::shared_ptr<Connection> DbConnPool::getMysqlConn()
  25. {
  26.     std::unique_lock<std::mutex> lock(m_queueMuetx);
  27.     // 判断队列是否为空
  28.     while(m_connQueue.empty()) {
  29.         // 队列为空，则等待 最大连接时间, 即这个时候客户端请求连接，但是池里没有连接了，则会等待，如果超过了最大时间，则：连接失败
  30.         if(std::cv_status::timeout == m_cv.wait_for(lock, std::chrono::seconds(m_maxConnTime))) {
  31.             // 再次判断是否为空
  32.             if(m_connQueue.empty()) {
  33.                 LOGGER("no conntion !!!!");
  34.                 return nullptr;
  35.             }
  36.         }
  37.     }
  39.     /*
  40.     从队列中获取一个连接，交给**智能指针管理**
  41.         注意：删除连接有回收线程监控，而这里获取的连接使用完后，需要还给**队列中**，所以**需要重写智能指针的回收函数**
  42.     */
  43.    std::shared_ptr<Connection> sp(m_connQueue.front(), [&](Connection* pconn){
  44.         // 注意，这里需要加锁
  45.         std::unique_lock<std::mutex> lock(m_queueMuetx);
  46.         pconn->setStartActivateTime();
  47.         m_connQueue.push(pconn);  // 入队
  48.         m_conntionCnt++;   // +1
  49.    });
  50.    // 弹出队列
  51.     m_connQueue.pop();
  52.     m_conntionCnt--;   // -1
  54.     return sp;
  55. }
  57. // 单例模型：构造函数私有化
  58. DbConnPool::DbConnPool()
  59. {
  60.     if(readConfigurationFile() == false) {
  61.         return;
  62.     }
  64.     std::unique_lock<std::mutex> lock(m_queueMuetx);
  65.     for(int i = 0; i < m_maxSize; i++) {
  66.         Connection* newConn = new Connection();
  67.         newConn->connectionSqlBase(m_ip, m_port, m_username, m_password, m_dbname);
  68.         newConn->setStartActivateTime();   // 设置 空闲时间 的起始点
  69.         m_connQueue.push(newConn);      // 入队
  70.         m_conntionCnt++;     // 存储到队列中数据+1
  71.     }
  73.     // 开启线程：检查是否需要需要**新创建连接**
  74.     std::thread produce(std::bind(&DbConnPool::produceNewConn, this));
  75.     produce.detach();   // 驻留后台
  76.     // 开启线程，检查是否需要**删除连接**
  77.     std::thread search(std::bind(&DbConnPool::recycleConn, this));
  78.     search.detach();    // 驻留后台
  79. }
  81. // 读取配置文件
  82. bool DbConnPool::readConfigurationFile()
  83. {
  84.     FILE* fp = fopen("./mysql.ini", "r");
  85.     if(fp == nullptr) {
  86.         LOGGER("mysql.ini open false!!");
  87.         return false;
  88.     }
  90.     char buff[BUFSIZ] = { 0 };
  92.     while(!feof(fp)) {
  93.         // clear
  94.         memset(buff, 0, sizeof(buff));
  95.         // 读取
  96.         fgets(buff, BUFSIZ, fp);
  97.         std::string str = buff;
  98.         // 判空
  99.         if(str.empty()) {
  100.             continue;
  101.         }
  102.         // 截断
  103.         int idx = str.find('=', 0);
  104.         if(idx == -1) {
  105.             continue;
  106.         }
  107.         int end = str.find('\n', idx);
  108.         std::string key = str.substr(0, idx);
  109.         std::string value = str.substr(idx + 1, end - idx - 1);
  110.         //std::cout << "key: " << key << " value: " << value << std::endl;
  112.         if(key == "ip") {
  113.             m_ip = value;
  114.         } else if(key == "port") {
  115.             m_port = atoi(value.c_str());
  116.         } else if(key == "username") {
  117.             m_username = value;
  118.         } else if(key == "password") {
  119.             m_password = value;
  120.         } else if(key == "dbname") {
  121.             m_dbname = value;
  122.         } else if(key == "initSize") {
  123.             m_initSize = atoi(value.c_str());
  124.         } else if(key == "maxSize") {
  125.             m_maxSize = atoi(value.c_str());
  126.         } else if(key == "maxFreeTime") {
  127.             m_maxFreeTime = atoi(value.c_str());
  128.         } else if(key == "maxConnTime") {
  129.             m_maxConnTime = atoi(value.c_str());
  130.         }
  131.     }
  133.     std::cout << m_ip << " " << m_port << " " << m_username << " " << m_password << " " << m_dbname << " " << m_initSize << " " << m_maxSize << " " << m_maxFreeTime << " " << m_maxConnTime << std::endl;
  135.     return true;
  136. }
  138. // 如果池里没有Mysql连接了，则产生新连接，这个线程驻留后台(像守护线程一样)
  139. /*
  140. 实现思路：
  141.     设置一个循环：循环检查
  142.         如果队列不为空，则条件变量一直等待
  143. */
  144. void DbConnPool::produceNewConn()
  145. {
  146.     for(;;) {
  147.         std::unique_lock<std::mutex> lock(m_queueMuetx);
  148.         while(!m_connQueue.empty()) {
  149.             m_cv.wait(lock);    // 条件变量一直等待
  150.         }
  152.         // 这个时候，队列为空，从新创建连接
  153.         for(int i = 0; i < m_maxSize; i++) {
  154.             Connection* newConn = new Connection();
  155.             newConn->setStartActivateTime();   // 刷新时间
  156.             m_connQueue.push(newConn);
  157.             m_conntionCnt++;   // +1
  158.         }
  160.         // 通知等待线程
  161.         m_cv.notify_all();
  162.     }
  163. }
  165. // 如果队列线程 > initSize， 且空闲时间大于最大空闲时间，则回收
  166. void DbConnPool::recycleConn()
  167. {
  168.     for(;;) {
  169.         std::unique_lock<std::mutex> lock(m_queueMuetx);
  170.         while(m_conntionCnt > m_initSize) {
  171.             Connection* conn = m_connQueue.front();
  172.             // 超过最大空闲时间
  173.             if((static_cast<double>(conn->getActivateTime()) / CLOCKS_PER_SEC) > m_maxFreeTime) {
  174.                 m_connQueue.pop();
  175.                 m_conntionCnt--;
  176.                 delete conn;
  177.             } else {   // 对头没超过，则直接退出
  178.                 break;
  179.             }
  180.         }
  181.     }
  182. }
复制代码
压力测试

分别插入10000条数据，对没有使用连接池和使用连接池分别进行测试。
  1. #include "dbConnectionPool.h"
  2. #include "connection.h"
  3. #include <iostream>
  4. #include <mysql/mysql.h>
  5. #include <chrono>
  7. int main() {
  8.     auto start = std::chrono::high_resolution_clock::now(); // 获取当前时间点
  10.     for(int i = 0; i < 10000; i++) {
  11. #if 1
  12.         DbConnPool* pool = DbConnPool::getDbConnPool();
  13.         std::shared_ptr<Connection> conn = pool->getMysqlConn();
  14.         char sql[1024] = { 0 };
  15.         sprintf(sql, "insert into temp(name, age, sex) values('%s', '%d', '%s');", "yxz", 18, "man");
  16.         conn->modify(sql);
  17. #elif  0
  18.         Connection conn;
  19.         conn.connectionSqlBase("127.0.0.1", 3306, "root", "wy2892586", "test");
  20.         char sql[1024] = { 0 };
  21.         sprintf(sql, "insert into temp(name, age, sex) values('%s', '%d', '%s');", "yxz", 18, "man");
  22.         conn.modify(sql);
  23. #endif
  24.     }
  26.     auto end = std::chrono::high_resolution_clock::now(); // 获取结束时间点
  27.     std::chrono::duration<double, std::milli> duration = end - start; // 计算持续时间，并转换为毫秒
  29.     std::cout << "Time: " << duration.count() << " ms" << std::endl;
  31.     return 0;
  32. }
复制代码
效果如下：


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

来自云龙湖轮廓分明的月亮

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表