C++11实现数据库连接池
关键技术点
MySQL数据库编程、单例模式、queue队列容器、C++11多线程编程、线程互斥、线程同步通信和 unique_lock、基于CAS的原子整形、智能指针shared_ptr、lambda表达式、生产者-消费者线程模型
项目背景
为了提高MySQL数据库（基于C/S设计）的访问瓶颈，除了在服务器端增加缓存服务器缓存常用的数据之外（例如redis），还可以增加连接池来提高MySQL Server的访问效率，在高并发情况下，
大量的TCP三次握手、MySQL Server连接认证、MySQL Server关闭连接回收资源和TCP四次挥手所耗费的性能时间也是很明显的，增加连接池就是为了减少这一部分的性能损耗。
在市场上比较流行的连接池包括阿里的druid，c3p0以及apache dbcp连接池，它们对于短时间内大量的数据库增删改查操作性能的提升是很明显的，但是它们有一个共同点就是，全部由Java实现的。
那么本项目就是为了在C/C++项目中，提供MySQL Server的访问效率，实现基于C++代码的数据库连接池模块。
连接池功能点
- 初始化连接池（创建指定数量的连接）
- 连接不足时生产新的连接
- 定时扫描空闲超过maxIdleTime的连接，释放空闲连接
- 从配置文件中解析配置项
开发平台
有关MySQL数据库编程、多线程编程、线程互斥和同步通信操作、智能指针、设计模式、容器等等这些技术在C++语言层面都可以直接实现。本项目选择在Linux下进行开发，Linux版本是：
Linux version 5.15.0-67-generic (buildd@lcy02-amd64-029) (gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0, GNU ld (GNU Binutils for Ubuntu) 2.34)
MySQL相关
show variables like 'max_connections';该命令可以查看MySQL Server所支持的最大连接个数，超过max_connections数量的连接，MySQL Server会直接拒绝，所以在使用连接池增加连接数量的时候，MySQL Server的max_connections参数也要适当的进行调整，以适配连接池的连接上限。
创建库和表
CREATE DATABASE chat;
CREATE TABLE IF NOT EXISTS `user`(
`id` INT(11) AUTO_INCREMENT,
`name` VARCHAR(150) DEFAULT NULL,
`age` int(11) DEFAULT NULL,
`sex` enum('male','female') DEFAULT NULL,
PRIMARY KEY ( `id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
连接池功能设计实现
连接类 Connection实现
该类主要实现数据库操作
// Connection.h
#ifndef CONNECTION_H
#define CONNECTION_H
// 实现数据库的操作
#include 连接池类ConnectionPool实现
- 配置文件解析函数
- 生产连接功能
- 定时回收释放连接功能
// CommonConnectionPool.h
// 防止头文件重复包含
#ifndef CONNECTIONPOOL_H
#define CONNECTIONPOOL_H
// 连接池功能模块
#include 实现
// CommonConnectionPool.cpp
#include "CommonConnectionPool.h"
#include "public.h"
// static函数定义，不需要带static
ConnectionPool *ConnectionPool::getConnectionPool()
{
// C++11保证线程安全
static ConnectionPool pool; // 编译器内部进行lock和unlock
return &pool;
}
bool ConnectionPool::loadConfigFile()
{
FILE *pf = fopen("mysql.conf", "r");
if (pf == nullptr)
{
LOG("mysql.conf file is not exist");
return false;
}
// feof判断文件是否到结尾
while (!feof(pf))
{
char line[1024] = {0};
fgets(line, 1024, pf); // 读取一行
string str = line;
int idx = str.find('=', 0);
if (idx == -1) // 无效配置项
{
continue;
}
// username=root
// parse
int endidx = str.find('\n', idx);
string key = str.substr(0, idx);
string value = str.substr(idx + 1, endidx - idx - 1);
// cout << "key:" << key << ", value :" << value << endl;
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)); // b
// detach()函数，让线程在后台运行住，意味着线程不能与之产生直接交互，后台线程的归属和控制都由C++运行时库处理。
produce.detach();
// 启动一个新的线程,执行定时扫描超过maxIdleTime空闲时间的连接，进行对于连接的回收
thread scanner(std::bind(&ConnectionPool::scannerConnectionTask, this));
// detach()函数，让线程在后台运行住，意味着线程不能与之产生直接交互，后台线程的归属和控制都由C++运行时库处理。
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，是保证wait_for被唤醒后，确实是从队列中取走连接了
// 有可能notify唤醒后该线程其实并没有获取到连接（waitfor内部锁加慢了一步，被别的消费者抢先了）
while(_connectionQue.empty())
{
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;
}
void ConnectionPool::scannerConnectionTask()
{
for(;;)
{
// sleep模拟定时效果，周期轮询
this_thread::sleep_for(chrono::seconds(_maxIdleTime));
// ???这个锁能往循环里放减小粒度吗
unique_lock<mutex> lock(_queueMutex);
// 只有连接总数大于初始连接数才考虑释放连接
while(_connectionCnt > _initSize)
{
// unique_lock lock(_queueMutex);
Connection *p = _connectionQue.front();
if(p->getAliveTime() >= (_maxIdleTime * 1000))
{
_connectionQue.pop();
_connectionCnt--;
delete p;
}
else
{
// 队头连接（最早变为空闲状态）都没有空闲超过_maxIdleTime ,后续连接更不会超过
break;
}
}
}
}
配置文件
# mysql.conf
# 数据库连接池配置文件
ip=127.0.0.1
port=3306
username=root
password=123456
dbname=chat
initSize=10
maxSize=1024
#最大空闲时间默认单位是秒
maxIdleTime=60
#连接超时时间为ms
connectionTimeOut=100
public.h
#pragma once
#define LOG(str) \
cout << __FILE__ << ":" << __LINE__ << " " << \
__TIMESTAMP__ << " : " << str << endl;
性能测试
编译
makefile文件如下
CXX ?= g++ #如果没有被赋值过就赋予等号后面的值
DEBUG ?= 1
ifeq ($(DEBUG), 1)
CXXFLAGS += -g
else
CXXFLAGS += -O2
endif
main: main.cpp Connection.cpp CommonConnectionPool.cpp
$(CXX) -o main $^ $(CXXFLAGS) -pthread -lmysqlclient
clean:
rm -r main
测试代码
// main.cpp
#include 测试结果
| 数据量 | 未使用连接池 | 使用连接池 |
|---|---|---|
| 1000 | 单线程：216725ms 四线程：53839ms | 单线程：2722ms 四线程：2476ms |
| 2000 | 单线程：431956ms 四线程：107929ms | 单线程： 3108ms 四线程：2695ms |
| 5000 | 单线程：1082188ms 四线程：272680ms | 单线程：4755ms 四线程：3396ms |
可见采用连接池后性能得到大幅度的提升，同时使用多线程也可以提升并发连接的效率
杂项
C++11 中 unique_lock和lock_guard区别
unique_lock 和 lock_guard 都是C++11中的互斥锁RAII（Resource Acquisition Is Initialization）类，用于管理互斥锁的生命周期，从而保证代码的线程安全性。
它们的区别在于：
灵活性不同
unique_lock 比 lock_guard 更加灵活，因为它提供了更多的操作。unique_lock 对象可以随时unlock()和lock()多次，而 lock_guard 对象一旦被初始化就不可以再unlock()或lock()了。
锁定时间不同
unique_lock 的锁定时间比 lock_guard 长，因为它可以延迟锁定（deferred lock），即可以在不锁定互斥量的情况下创建一个 unique_lock 对象，然后在合适的时候再锁定互斥量。这个功能对于需要跨多个函数的操作非常有用。
开销不同
由于 unique_lock 更加灵活，所以在使用时会产生更多的开销。相比之下，lock_guard 对象的构造和析构函数所需的开销较小。
所有权转移
unique_lock 对象可以转移所有权（move ownership），这意味着一个 unique_lock 对象可以被移动到另一个对象中，而不需要释放锁，这对于编写返回锁定的函数非常有用。
总的来说，如果你需要更加灵活的互斥量管理方式并且可以容忍稍微的开销，那么 unique_lock 是一个不错的选择。如果你只需要简单的锁定，并且需要尽可能地减小开销，那么 lock_guard 是更好的选择。
课外阅读
线程安全的单例模式