在实际的项目中,使用线连接池是非常广泛的,所以最近学习了连接池的开发,在此做一个总结。
目的
为了提高MySQL数据库(基于C/S设计)的访问瓶颈,除了在服务器端增加缓存服务器缓存常用的数据之外(例如redis),还可以增加连接池,来提高MySQLServer的访问效率,在高并发情况下,大量的TCP三次握手、MySQL Server连接认证、MySQL Server关闭连接回收资源和TCP四次挥手所耗费的性能时间也是很明显的,增加连接池就是为了减少这一部分的性能损耗。
那么本项目就是为了在C/C++项目中,提供MySQL Server的访问效率,实现基于C++代码的数据库连接池模块,也是一个通用的连接池模型。
功能点
连接池一般包含了数据库连接所用的ip地址、port端口号、用户名和密码以及其它的性能参数,例如初始连接量,最大连接量,最大空闲时间、连接超时时间等,该项目是基于C++语言实现的连接池,主要也是实现以上几个所有连接池都支持的通用基础功能。
- 初始连接量(initsize)):表示连接池事先会和MySQLServer创建initSize个数的connection连接,当应用发起MySQL访问时,不用再创建和MySQLServer新的连接,直接从连接池中获取一个可用的连接就可以,使用完成后,并不去释放connection,而是把当前connection再归还到连接池当中。
- 最大连接量(maxsize):当并发访问MySQLServer的请求增多时,初始连接量已经不够使用了,此时会根据新的请求数量去创建更多的连接给应用去使用,但是新创建的连接数量上限是maxSize,不能无限制的创建连接,因为每一个连接都会占用一个socket资源,一般连接池和服务器程序是部署在一台主机上的,如果连接池占用过多的socket资源,那么服务器就不能接收太多的客户端请求了。当这些连接使用完成后,再次归还到连接池当中来维护。
- 最大空闲时间(maxldleTime):当访问MSQL的并发请求多了以后,连接池里面的连接数量会动态增加,上限是maxSize个,当这些连接用完再次归还到连接池当中。如果在指定的maxldleTime里面这些新增加的连接都没有被再次使用过,那么新增加的这些连接资源就要被回收掉,只需要保持初始连接量initSize个连接就可以了。
- 连接超时时间(connectionTimeout):当MVSOL的并发请求量过大,连接池中的连接数量已经到达maxSize了,而此时没有空闲的连接可供使用,那么此时应用从连接池获取连接无法成功,它通过阻塞的方式获取连接的时间如果超过connectionTimeout时间,那么获取连接失败,无法访问数据库。
该项目主要实现上述的连接池四大功能,其余连接池更多的扩展功能,可以自行实现。
功能实现设计
ConnectionPool.cpp和ConnectionPool.h:连接池代码实现Connection.cpp和Connection.h:数据库操作代码、增删改查代码实现
连接池主要包含了以下功能点:
- 连接池只需要一个实例,所以ConnectionPool以单例模式进行设计
- 从ConnectionPool中可以获取和MySQL的连接Connection
- 空闲连接Connection全部维护在一个线程安全的Connection队列中,使用线程互斥锁保证队列的线程安全
- 如果Connection队列为空,还需要再获取连接,此时需要动态创建连接,上限数量是maxSize
- 在独立的线程中确保队列中空闲连接时间超过maxldleTime的就要被释放掉,只保留初始的initSize个连接就可以
- 如果Connection队列为空,而此时连接的数量已达上限maxSize,那么等待connectionTimeout时间如果还获取不到空闲的连接,那么获取连接失败,此处从Connection队列获取空闲连接,可以使用带超时时间的mutex互斥锁来实现连接超时时间
- 用户获取的连接用shared_ptr智能指针来管理,用lambda表达式定制连接释放的功能(不真正释放连接,而是把连接归还到连接池中)
- 连接的生产和连接的消费采用生产者-消费者线程模型来设计,使用了线程间的同步通信机制条件变量和互斥锁。
配置文件
#数据库连接池的配置文件
ip=127.0.0.1
port=3306
username=root
password=xxxxxx//自己数据库的密码
dbname=chatp
initSize=10
maxSize=1024
#最大空闲时间默认单位是秒
maxIdleTime=60
#连接超时时间单位是毫秒
connectionTimeOut=100
MySQL数据库C++代码–对应Connection.cpp中
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);
}
Connection.h
#pragma once
#ifndef CONNECTION_H
#define CONNECTION_H
#include <mysql/mysql.h>
#include <string>
#include <ctime>
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; // 记录进入空闲状态后(进入队列)的起始存活时间
};
#endif
连接池CommonConnectionPool.cpp
重要成员变量
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; // 设置条件变量,用于连接生产线程和连接消费线程的通信
};
- 作用如备注
重要成员函数
获取单例连接池对象
//1. 构造函数私有化
...
private:
// 单例#1 构造函数私有化
ConnectionPool();
...
//2. 获取单例接口
ConnectionPool* ConnectionPool::getConnectionPool()
{
static ConnectionPool pool; // lock和unlock
return &pool;
}
从配置文件中加载配置项
bool ConnectionPool::loadConfigFile()
{
FILE *pf = fopen("/root/conn_Pool/src/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;//char转变为string
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++;
}
thread produce(std::bind(&ConnectionPool::produceConnectionTask, this));
produce.detach();
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())
{
// 等待_connectionTimeout以内,如果有可以获取的连接就通知
// timeout确保是因为超时醒的,避免因为被唤醒但是被其他线程取走的情况
if (cv_status::timeout == cv.wait_for(lock, chrono::milliseconds(_connectionTimeout)))
{
// 等待_connectionTimeout时间以后,没有人唤醒,自己醒了说明还是没有可用的连接
if (_connectionQue.empty())
{
LOG("获取空闲连接超时了...获取连接失败!");
return nullptr;
}
}
}
/*
shared_ptr智能指针析构时,会把connection资源直接delete掉,相当于
调用connection的析构函数,connection就被close掉了。
这里需要自定义shared_ptr的释放资源的方式,把connection直接归还到queue当中
shared_ptr第二个参数可以接受一个删除器
*/
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;
}
连接回收
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,其它连接肯定没有
}
}
}
}
压测
#include <iostream>
using namespace std;
#include "Connection.h"
#include "CommonConnectionPool.h"
int main()
{
#if 0
/*
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
*/
/*Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "male");
conn.connect("127.0.0.1", 3306, "root", "123456", "chat");
conn.update(sql);*/
clock_t begin = clock();
thread t1([]() {
ConnectionPool *cp = ConnectionPool::getConnectionPool();
for (int i = 0; i < 2500; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
/*
Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
conn.update(sql)
*/
}
});
thread t2([]() {
ConnectionPool *cp = ConnectionPool::getConnectionPool();
for (int i = 0; i < 2500; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
/*
Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
conn.update(sql)
*/
}
});
thread t3([]() {
ConnectionPool *cp = ConnectionPool::getConnectionPool();
for (int i = 0; i < 2500; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
/*
Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
conn.update(sql)
*/
}
});
thread t4([]() {
ConnectionPool *cp = ConnectionPool::getConnectionPool();
for (int i = 0; i < 2500; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
/*
Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
conn.update(sql)
*/
}
});
t1.join();
t2.join();
t3.join();
t4.join();
clock_t end = clock();
cout << (end - begin) << "ms" << endl;
#endif
clock_t begin = clock();
ConnectionPool *cp = ConnectionPool::getConnectionPool();
//单线程
for (int i = 0; i < 10000; ++i)
{
/*
Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
conn.update(sql);
*/
shared_ptr<Connection> sp = cp->getConnection();
char sql[1024] = { 0 };
sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
"zhang san", 20, "M");
sp->update(sql);
}
clock_t end = clock();
cout << (end - begin) << "ms" << endl;
return 0;
}
压测数据
数据量 | 未使用连接池花费时间 | 使用连接池花费时间 |
---|---|---|
1000 | 单线程4630000ms 四线程:5360000ms | 单线程 80000ms 四线程:80000ms |
5000 | 单线程22870000ms 四线程:26990000ms | 单线程 210000ms 四线程:210000ms |
10000 | 单线程45700000ms 四线程:53820000ms | 单线程 360000ms 四线程:370000ms |
注意:如果在window下开发:
在VS上需要进行相应的头文件和库文件的配置,如下:
-
右键项目 - C/C++ - 常规 - 附加包含目录,填写mysql.h头文件的路径;
-
右键项目 - 链接器 - 常规 - 附加库目录,填写libmysql.lib的路径;
-
右键项目 - 链接器 - 输入 - 附加依赖项,填写libmysql.lib库的名字;
-
把libmysql.dll动态链接库(Linux下后缀名是.so库)放在工程目录下;