C++ mysql连接池附带讲解与详细注释源码

本文链接：https://blog.csdn.net/q2453303961/article/details/125522931

https://github.com/wakk3107/wakk_MySQLConnectionPool

文章目录

开发平台
关键技术点
压力测试
MySQL Server参数介绍
功能实现设计
源码部分

开发平台

Windows VS2019 x64，故想要运行，得自己先配置好项目的mysql的库路径
可以参考下面链接
https://blog.csdn.net/yuckh/article/details/108339616

关键技术点

MySQL数据库编程、单例模式、queue队列容器、C++11多线程编程、线程互斥、线程同步通信和
unique_lock、基于CAS的原子整形、智能指针shared_ptr、lambda表达式、生产者-消费者线程模型

压力测试

数据量	未使用连接池花费时间	使用连接池花费时间
1000	单线程：2130ms，四线程：623ms	单线程：1260ms，四线程：557ms
5000	单线程：10623ms，四线程：2804ms	单线程：6324ms，四线程：2602ms
10000	单线程：20353ms，四线程：5456ms	单线程：12865ms，四线程：5241ms

MySQL Server参数介绍

连接池一般包含了数据库连接所用的ip地址、port端口号、用户名和密码以及其它的性能参数，例如初
始连接量，最大连接量，最大空闲时间、连接超时时间等，该项目是基于C++语言实现的连接池，主要
也是实现以上几个所有连接池都支持的通用基础功能。

初始连接量（initSize）：表示连接池事先会和MySQL Server创建initSize个数的connection连接，当应用发起MySQL访问时，不用再创建和MySQL Server新的连接，直接从连接池中获取一个可用的连接就可以，使用完成后，并不去释放connection，而是把当前connection再归还到连接池当中。
最大连接量（maxSize）：当并发访问MySQL Server的请求增多时，初始连接量已经不够使用了，此时会根据新的请求数量去创建更多的连接给应用去使用，但是新创建的连接数量上限是maxSize，不能无限制的创建连接，因为每一个连接都会占用一个socket资源，一般连接池和服务器程序是部署在一台主机上的，如果连接池占用过多的socket资源，那么服务器就不能接收太多的客户端请求了。当这些连接使用完成后，再次归还到连接池当中来维护。
最大空闲时间（maxIdleTime）：当访问MySQL的并发请求多了以后，连接池里面的连接数量会动态增加，上限是maxSize个，当这些连接用完再次归还到连接池当中。如果在指定的maxIdleTime里面，这些新增加的连接都没有被再次使用过，那么新增加的这些连接资源就要被回收掉，只需要保持初始连接量initSize个连接就可以了。
连接超时时间（connectionTimeout）：当MySQL的并发请求量过大，连接池中的连接数量已经到达maxSize了，而此时没有空闲的连接可供使用，那么此时应用从连接池获取连接无法成功，它通过阻塞的方式获取连接的时间如果超过connectionTimeout时间，那么获取连接失败，无法访问数据库。该项目主要实现上述的连接池四大功能，其余连接池更多的扩展功能，可以自行实现。

mysql> show variables like 'max_connections';

//该命令可以查看MySQL Server所支持的最大连接个数，超过max_connections数量的连接，MySQL
//Server会直接拒绝，所以在使用连接池增加连接数量的时候，MySQL Server的max_connections参数
//也要适当的进行调整，以适配连接池的连接上限。

功能实现设计

ConnectionPool.cpp和ConnectionPool.h：连接池代码实现
Connection.cpp和Connection.h：对C语言mysql连接操作的进一步封装

连接池主要包含了以下功能点：

连接池只需要一个实例，所以ConnectionPool以单例模式进行设计
从ConnectionPool中可以获取MySQL的连接Connection
空闲连接Connection全部维护在一个线程安全的Connection队列中，使用线程互斥锁保证队列的线程安全
如果Connection队列为空，还需要再获取连接，此时需要动态创建连接，上限数量是maxSize
队列中空闲连接时间超过maxIdleTime的就要被释放掉，只保留初始的initSize个连接就可以了，这个功能点肯定需要放在独立的线程中去做
如果 Connection队列为空，而此时连接的数量已达上限 maxSize，那么等待connectionTimeout时间如果还获取不到空闲的连接，那么获取连接失败，此处从 Connection队列获取空闲连接，可以使用带超时时间的 mutex互斥锁来实现连接超时时间
用户获取的连接用shared_ptr智能指针来管理，用lambda表达式定制连接释放的功能（不真正释放连接，而是把连接归还到连接池中）
连接的生产和连接的消费采用生产者-消费者线程模型来设计，使用了线程间的同步通信机制条件变量和互斥锁

源码部分

Connection.h 就是包装一下C语言API

#include <string>
//加上该宏才能正常使用mysql.h,不然会报错
//经查询好像是因为mysql.h依赖的东西根据平台不同包括在不同的头文件下
#ifdef _MSC_VER
#ifdef _WIN64
#include <WinSock2.h>
#elif _WIN32
#include <winsock.h>
#endif
#endif
#include <mysql.h>
#include"public.h"

using namespace std;
/*
实现MySQL数据库的操作
*/
class Connection
{
    public:
    // 初始化数据库连接
    Connection();
    // 释放数据库连接资源
    ~Connection();
    // 连接数据库
    bool connect(string ip,
                 unsigned short port,
                 string user,
                 string password,
                 string dbname);
    // 更新操作 insert、delete、update
    bool update(string sql);
    // 查询操作 select
    MYSQL_RES* query(string sql);
    
    // 刷新一下连接的起始的空闲时间点
    void refreshAliveTime() { _alivetime = clock(); }
    // 返回存活的时间
    clock_t getAliveeTime()const { return clock() - _alivetime; }
    private:
    MYSQL* _conn; // 表示和MySQL Server的一条连接
    clock_t _alivetime; // 记录进入空闲状态后的起始存活时间
};

Connection.cpp 就是包装一下C语言API

#include "public.h"
#include "Connection.h"
using namespace std;

Connection::Connection()
{
	// 初始化数据库连接
	_conn = mysql_init(nullptr);
}

Connection::~Connection()
{
	// 释放数据库连接资源
	if (_conn != nullptr)
		mysql_close(_conn);
}

bool Connection::connect(string ip, unsigned short port,
	string username, string password, string dbname)
{
	// 连接数据库
	MYSQL* p = mysql_real_connect(_conn, ip.c_str(), username.c_str(),
		password.c_str(), dbname.c_str(), port, nullptr, 0);
	return p != nullptr;
}

bool Connection::update(string sql)
{
	// 更新操作 insert、delete、update
	if (mysql_query(_conn, sql.c_str()))
	{
		LOG("更新失败:" + sql);
		return false;
	}
	return true;
}

MYSQL_RES* Connection::query(string sql)
{
	// 查询操作 select
	if (mysql_query(_conn, sql.c_str()))
	{
		LOG("查询失败:" + sql);
		return nullptr;
	}
	return mysql_use_result(_conn);
}

ConnectionPool.h 连接池的声明

#include"Connection.h"
#include<queue>
#include<mutex>
#include<thread>
#include<atomic>
#include<functional>
class ConnectionPool {
public:
	//获取连接池对象实例
	static ConnectionPool* getConnectionPool();
	shared_ptr<Connection> getConnection();
	
private:
    //加载配置文件 文件名 为 mysql.ini
	bool loadConfigFile();
	//生产新链接的线程函数
	void produceConnectionTask();
	void scannerConnectionTask();
	ConnectionPool();//单例1:构造函数私有化
	string _ip; // mysql的ip地址
	unsigned short _port; // mysql的端口号 3306
	string _username; // mysql登录用户名
	string _password; // mysql登录密码
	string _dbname; // 连接的数据库名称
	int _initSize; // 连接池的初始连接量
	int _maxSize; // 连接池的最大连接量
	int _maxIdleTime; // 连接池最大空闲时间
	int _connectionTimeout; // 连接池获取连接的超时时间

	queue<Connection*> _connectionQue; // 存储mysql连接的队列
	mutex _queueMutex; // 维护连接队列的线程安全互斥锁
	atomic_int _connectionCnt; // 记录连接所创建的connection连接的总数量 
	condition_variable cv; // 设置条件变量，用于连接生产线程和连接消费线程的通信
};

ConnectionPool.cpp 连接池的定义

#include "CommonConnectionPool.h"
#include "public.h"

// 线程安全的懒汉单例函数接口
ConnectionPool* ConnectionPool::getConnectionPool()
{
	static ConnectionPool pool; // lock和unlock
	return &pool;
}

// 从配置文件中加载配置项
bool ConnectionPool::loadConfigFile()
{
	FILE* pf = fopen("mysql.ini", "r");
	if (pf == nullptr)
	{
		LOG("mysql.ini file is not exist!");
		return false;
	}

	while (!feof(pf))
	{
		char line[1024] = { 0 };
		fgets(line, 1024, pf);
		string str = line;
		int idx = str.find('=', 0);
		if (idx == -1) // 无效的配置项
		{
			continue;
		}

		// password=123456\n
		int endidx = str.find('\n', idx);
		string key = str.substr(0, idx);
		string value = str.substr(idx + 1, endidx - idx - 1);

		if (key == "ip")
		{
			_ip = value;
		}
		else if (key == "port")
		{
			_port = atoi(value.c_str());
		}
		else if (key == "username")
		{
			_username = value;
		}
		else if (key == "password")
		{
			_password = value;
		}
		else if (key == "dbname")
		{
			_dbname = value;
		}
		else if (key == "initSize")
		{
			_initSize = atoi(value.c_str());
		}
		else if (key == "maxSize")
		{
			_maxSize = atoi(value.c_str());
		}
		else if (key == "maxIdleTime")
		{
			_maxIdleTime = atoi(value.c_str());
		}
		else if (key == "connectionTimeOut")
		{
			_connectionTimeout = atoi(value.c_str());
		}
	}
	return true;
}

// 连接池的构造
ConnectionPool::ConnectionPool()
{
	// 加载配置项了
	if (!loadConfigFile())
	{
		return;
	}

	// 创建初始数量的连接
	for (int i = 0; i < _initSize; ++i)
	{
		Connection* p = new Connection();
		p->connect(_ip, _port, _username, _password, _dbname);
		p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
		_connectionQue.push(p);
		_connectionCnt++;
	}

	// 启动一个新的线程，作为连接的生产者 linux thread => pthread_create
	thread produce(std::bind(&ConnectionPool::produceConnectionTask, this));
	produce.detach();

	// 启动一个新的定时线程，扫描超过maxIdleTime时间的空闲连接，进行对于的连接回收
	thread scanner(std::bind(&ConnectionPool::scannerConnectionTask, this));
	scanner.detach();
}

// 运行在独立的线程中，专门负责生产新连接
void ConnectionPool::produceConnectionTask()
{
	for (;;)
	{
		unique_lock<mutex> lock(_queueMutex);
		while (!_connectionQue.empty())
		{
			cv.wait(lock); // 队列不空，此处生产线程进入等待状态
		}

		// 连接数量没有到达上限，继续创建新的连接
		if (_connectionCnt < _maxSize)
		{
			Connection* p = new Connection();
			p->connect(_ip, _port, _username, _password, _dbname);
			p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
			_connectionQue.push(p);
			_connectionCnt++;
		}

		// 通知消费者线程，可以消费连接了
		cv.notify_all();
	}
}

// 给外部提供接口，从连接池中获取一个可用的空闲连接
shared_ptr<Connection> ConnectionPool::getConnection()
{
	unique_lock<mutex> lock(_queueMutex);
	while (_connectionQue.empty())
	{
		// sleep
		if (cv_status::timeout == cv.wait_for(lock, chrono::milliseconds(_connectionTimeout)))
		{
			if (_connectionQue.empty())
			{
				LOG("获取空闲连接超时了...获取连接失败!");
				return nullptr;
			}
		}
	}

	/*
	shared_ptr智能指针析构时，会把connection资源直接delete掉，相当于
	调用connection的析构函数，connection就被close掉了。
	这里需要自定义shared_ptr的释放资源的方式，把connection直接归还到queue当中
	*/
	shared_ptr<Connection> sp(_connectionQue.front(),
		[&](Connection* pcon) {
			// 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
			unique_lock<mutex> lock(_queueMutex);
			pcon->refreshAliveTime(); // 刷新一下开始空闲的起始时间
			_connectionQue.push(pcon);
		});

	_connectionQue.pop();
	cv.notify_all();  // 消费完连接以后，通知生产者线程检查一下，如果队列为空了，赶紧生产连接

	return sp;
}

// 扫描超过maxIdleTime时间的空闲连接，进行对于的连接回收
void ConnectionPool::scannerConnectionTask()
{
	for (;;)
	{
		// 通过sleep模拟定时效果
		this_thread::sleep_for(chrono::seconds(_maxIdleTime));

		// 扫描整个队列，释放多余的连接
		unique_lock<mutex> lock(_queueMutex);
		while (_connectionCnt > _initSize)
		{
			Connection* p = _connectionQue.front();
			if (p->getAliveeTime() >= (_maxIdleTime * 1000))
			{
				_connectionQue.pop();
				_connectionCnt--;
				delete p; // 调用~Connection()释放连接
			}
			else
			{
				break; // 队头的连接没有超过_maxIdleTime，其它连接肯定没有
			}
		}
	}
}

mysql.ini 配置文件，放在项目目录下

#数据库的配置文件
ip=127.0.0.1
port=3306
dbname=javaweb_login
username=root
password=245330
initSize=10
maxSize=1024
#秒
maxIdleTime=60
#毫秒
maxConnectionTimeOut=100

main.cpp 测试文件

#include"CommonConnectionPool.h"
using namespace std;
int main() {
	clock_t begin = clock();
	ConnectionPool* p = ConnectionPool::getConnectionPool();

	thread t1([]() {
		for (int i = 0; i < 250; i++) {
		/*Connection conn;
		char sql[1024];
		sprintf(sql," insert into user values(NULL, '%d', '%d')",i,i);
		conn.connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
		conn.update(sql);*/

		ConnectionPool* p = ConnectionPool::getConnectionPool();
		shared_ptr<Connection> conn = p->getConnection();
		char sql[1024];
		sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
		conn->connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
		conn->update(sql);


		}
		});
	thread t2([]() {
		for (int i = 250; i < 500; i++) {
			/*Connection conn;
			char sql[1024];
			sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
			conn.connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
			conn.update(sql);*/

			ConnectionPool* p = ConnectionPool::getConnectionPool();
			shared_ptr<Connection> conn = p->getConnection();
			char sql[1024];
			sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
			conn->connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
			conn->update(sql);


		}
		});
	thread t3([]() {
		for (int i = 500; i < 750; i++) {
		/*	Connection conn;
			char sql[1024];
			sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
			conn.connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
			conn.update(sql);*/

			ConnectionPool* p = ConnectionPool::getConnectionPool();
			shared_ptr<Connection> conn = p->getConnection();
			char sql[1024];
			sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
			conn->connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
			conn->update(sql);


		}
		});
	thread t4([]() {
		for (int i = 750; i < 1000; i++) {
		/*	Connection conn;
			char sql[1024];
			sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
			conn.connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
			conn.update(sql);*/

			ConnectionPool* p = ConnectionPool::getConnectionPool();
			shared_ptr<Connection> conn = p->getConnection();
			char sql[1024];
			sprintf(sql, " insert into user values(NULL, '%d', '%d')", i, i);
			conn->connect("127.0.0.1", 3306, "root", "245330", "javaweb_login");
			conn->update(sql);


		}
		});
	t1.join();
	t2.join();
	t3.join();
	t4.join();

	clock_t end = clock();
	cout << end - begin << "ms" << endl;
	getchar();
}