引言:
数据库连接池和线程池的思想一样,是为了避免频繁创建和销毁数据库连接导致的性能开销。如果一个项目频繁的需要访问数据库,那么它就有可能需要频繁的创建/销毁数据库连接,那么我们可以采用数据库连接池的技术,在需要时,从数据库连接池中获取数据库连接,在用完数据库连接后再将它重新放回连接池中.
本文章所有代码大都来自开源项目:TinyWebServer
目录
- 设计模式:单例模式
- 数据库连接池
- 头文件与基本函数
- 连接池初始化
- 获取数据库连接
- 释放当前使用的连接
- 销毁整个连接池
- 源代码
设计模式:单例模式
单例模式就是指一个类有且只能有一个实例
实现单例模式的方法:
1.定义一个静态成员变量,用来保存唯一的一个实例
2.定义一个静态成员函数,用来让其他对象可以获取到这个实例
3.将构造函数设置为私有,防止其他类进行实例化对象
单例模式的好处:
1.避免多次实例化造成的性能和资源的开销
2.共享资源,由于只有一个实例,多个对象可以共享这个实例,实现资源共享和协作
小白对单例模式的误区:
单例模式是指该类只有一个实例,这个实例是保存在类中的静态成员变量中的,因为static关键字,所以所有的对象可以共享这个实例,并通过静态成员函数获取这个实例;但是这并不代表,单例模式只能创建一个对象,单例模式是可以创建多个对象的,然后这些对象通过静态成员函数获取实例将实例赋值给自己,实现相应的操作和共享数据等功能.
一个简单的单例模式的代码:
#include <iostream>class Singleton {
private:static Singleton* instance; // 单例实例// 私有构造函数,防止外部实例化Singleton() {}public:// 获取单例实例的静态方法static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}// 示例方法void showMessage() {std::cout << "Hello, I am a Singleton instance." << std::endl;}
};// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;int main() {Singleton* singleton1 = Singleton::getInstance();singleton1->showMessage();Singleton* singleton2 = Singleton::getInstance();singleton2->showMessage();// 判断两个实例是否相等if (singleton1 == singleton2) {std::cout << "Both instances are the same." << std::endl;} else {std::cout << "Instances are different." << std::endl;}return 0;
}
数据库连接池
头文件与基本函数
使用数据库所需要的头文件:
#include <mysql/mysql.h>
接下来将介绍几个跟数据库有关的函数:
1.mysql_init
int mysql_init(MYSQL *mysql)
用于初始化一个mysql对象
2.mysql_real_connect
MYSQL *mysql_real_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd, const char *db, unsigned int port, const char *unix_socket, unsigned long client_flag)
建立与mysql服务器的连接
参数1: MYSQL对象指针,用于接收连接句柄。
参数2: MySQL服务器主机名或IP地址。
参数3: MySQL用户名。
参数4: MySQL密码。
参数5: MySQL数据库名。
参数6: MySQL服务器端口号。
参数7: 额外的连接选项,可以为NULL。
3.mysql_close()
void mysql_close(MYSQL *mysql)
关闭与Mysql服务器的连接.
先只介绍这三个函数,因为我们的连接池只用这三个函数就可以实现,如果对其他函数感兴趣,可以去查找
头文件 <mysql/mysql.h>下的常用函数
TinyWebServer中
sql_connection_pool.h文件中的定义:
下面我会根据
TinywebServer项目中的
sql_connection_pool.cpp文件中对这些函数的具体实现做出分析来讲解数据库连接池
连接池初始化
void connection_pool::init(string url, string User, string PassWord, string DBName, int Port, int MaxConn, int close_log)
{m_url = url;m_Port = Port;m_User = User;m_PassWord = PassWord;m_DatabaseName = DBName;m_close_log = close_log;for (int i = 0; i < MaxConn; i++){MYSQL *con = NULL;con = mysql_init(con);//初始化一个mysql结构体对象!if (con == NULL){LOG_ERROR("MySQL Error");//日志记录错误!exit(1);}con = mysql_real_connect(con, url.c_str(), User.c_str(), PassWord.c_str(), DBName.c_str(), Port, NULL, 0);if (con == NULL){LOG_ERROR("MySQL Error");exit(1);}connList.push_back(con);//将这个链接放入连接池队列中!++m_FreeConn;//空闲的链接数+1;}reserve = sem(m_FreeConn); //信号量 sem=sem(m_MaxConn = m_FreeConn;//最多连接数=当前所有空闲的连接数!
}
1.首先初始化自己的URL,端口,数据库用户名,数据库密码,数据库名,还有日志名等属性
2.然后根据最大的连接数,按照循环的方式,创建数据库连接,然后把数据库连接放入线程池,并更新信息:
2.1:先用mysql_init函数初始化一个mysql对象
2.2:用mysql_real_connect将mysql对象和数据库连接
2.3:将这个mysql对象添加到连接池队列中
2.4:更新基本信息:空闲的连接数+1
3.初始化一个信号量,信号量的初始值为数据库连接池中的连接数
4.更新基本信息,数据库连接池上限=当前空闲的连接数.
获取数据库连接
MYSQL *connection_pool::GetConnection()
{MYSQL *con = NULL;if (0 == connList.size())return NULL;reserve.wait();lock.lock();con = connList.front();connList.pop_front();--m_FreeConn;++m_CurConn;lock.unlock();return con;
}
获取数据库连接就是从连接池中取出一个连接然后使用,步骤如下:
1.首先创建一个MYSQL对象指针,并设置为空
2.判断连接池中是否有连接,如果没有,那就拿取失败
3.信号量wait操作,让信号量的值-1,意味着我要开始拿资源了,如果信号量的值为0的话,此线程会被阻塞住,从而无法继续申请互斥锁拿资源.
4.加上互斥锁,防止多个线程同时拿取资源导致错误
5.从连接池中取出第一个连接
6.更改基本信息,空闲的连接-1,当前使用的连接数+1
7.释放互斥锁,让其他线程也能申请互斥锁拿资源
释放当前使用的连接
bool connection_pool::ReleaseConnection(MYSQL *con)
{if (NULL == con)return false;lock.lock();connList.push_back(con);++m_FreeConn;--m_CurConn;lock.unlock();reserve.post();return true;
}
使用完一个数据库连接之后,应该再把这个连接放回连接池,步骤如下:
1.判断所要销毁的连接是否为空,如果为空,则直接退出
2.申请互斥锁,避免有其他的线程也进行释放操作
3.将这个连接放回连接池
4.更新基本信息:空闲连接+1,当前使用连接-1
5.将信号量的值+1,唤醒之前因为信号量所阻塞的线程,让他们可以继续申请互斥锁并获取连接.
销毁整个连接池
void connection_pool::DestroyPool()
{lock.lock();if (connList.size() > 0){list<MYSQL *>::iterator it;for (it = connList.begin(); it != connList.end(); ++it){MYSQL *con = *it;mysql_close(con);}m_CurConn = 0;m_FreeConn = 0;connList.clear();}lock.unlock();
}
将整个数据库连接池销毁,步骤如下:
1.加上互斥锁,避免多线程同时执行销毁操作
2.遍历整个连接池,使用mysql_close函数关闭连接池中的所有连接
3.更新基本信息:空闲连接=0,当前连接=0
4.清空整个连接池List
5.释放互斥锁
源代码
sql_connection_pool.cpp
#include <mysql/mysql.h>
#include <stdio.h>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <list>
#include <pthread.h>
#include <iostream>#include "sql_connection_pool.h"using namespace std;connection_pool::connection_pool()
{m_CurConn = 0;m_FreeConn = 0;
}connection_pool *connection_pool::GetInstance()
{static connection_pool connPool;return &connPool;
}//构造初始化
void connection_pool::init(string url, string User, string PassWord, string DBName, int Port, int MaxConn, int close_log)
{m_url = url;m_Port = Port;m_User = User;m_PassWord = PassWord;m_DatabaseName = DBName;m_close_log = close_log;for (int i = 0; i < MaxConn; i++){MYSQL *con = NULL;con = mysql_init(con);//初始化一个mysql结构体对象!if (con == NULL){LOG_ERROR("MySQL Error");//日志记录错误!exit(1);}con = mysql_real_connect(con, url.c_str(), User.c_str(), PassWord.c_str(), DBName.c_str(), Port, NULL, 0);//mysql.h中用于建立实际数据库连接的函数。它的原型声明如下://if (con == NULL){LOG_ERROR("MySQL Error");exit(1);}connList.push_back(con);//将这个链接放入连接池队列中!++m_FreeConn;//空闲的链接数+1;}reserve = sem(m_FreeConn); //信号量 sem=sem(m_MaxConn = m_FreeConn;//最多连接数=当前所有空闲的连接数!
}//当有请求时,从数据库连接池中返回一个可用连接,更新使用和空闲连接数
MYSQL *connection_pool::GetConnection()
{MYSQL *con = NULL;if (0 == connList.size())return NULL;reserve.wait();lock.lock();con = connList.front();connList.pop_front();--m_FreeConn;++m_CurConn;lock.unlock();return con;
}//释放当前使用的连接
bool connection_pool::ReleaseConnection(MYSQL *con)
{if (NULL == con)return false;lock.lock();connList.push_back(con);++m_FreeConn;--m_CurConn;lock.unlock();reserve.post();return true;
}//销毁数据库连接池
void connection_pool::DestroyPool()
{lock.lock();if (connList.size() > 0){list<MYSQL *>::iterator it;for (it = connList.begin(); it != connList.end(); ++it){MYSQL *con = *it;mysql_close(con);}m_CurConn = 0;m_FreeConn = 0;connList.clear();}lock.unlock();
}//当前空闲的连接数
int connection_pool::GetFreeConn()
{return this->m_FreeConn;
}connection_pool::~connection_pool()
{DestroyPool();
}connectionRAII::connectionRAII(MYSQL **SQL, connection_pool *connPool){*SQL = connPool->GetConnection();conRAII = *SQL;poolRAII = connPool;
}connectionRAII::~connectionRAII(){poolRAII->ReleaseConnection(conRAII);
}
sql_connection_pool.h
#ifndef _CONNECTION_POOL_
#define _CONNECTION_POOL_#include <stdio.h>
#include <list>
#include <mysql/mysql.h>
#include <error.h>
#include <string.h>
#include <iostream>
#include <string>
#include "../lock/locker.h"
#include "../log/log.h"using namespace std;class connection_pool
{
public:MYSQL *GetConnection(); //获取一个数据库连接bool ReleaseConnection(MYSQL *conn); //释放一个数据库连接int GetFreeConn(); //获取空闲的连接数void DestroyPool(); //销毁整个连接池//单例模式static connection_pool *GetInstance();void init(string url, string User, string PassWord, string DataBaseName, int Port, int MaxConn, int close_log);
private:connection_pool();~connection_pool();int m_MaxConn; //最大连接数int m_CurConn; //当前已使用的连接数int m_FreeConn; //当前空闲的连接数locker lock; //定义了一个互斥锁list<MYSQL *> connList; //连接池sem reserve; //定义了一个信号量,叫reserve.用来记录空闲的连接数public:string m_url; //主机地址string m_Port; //数据库端口号string m_User; //登陆数据库用户名string m_PassWord; //登陆数据库密码string m_DatabaseName; //使用数据库名int m_close_log; //日志开关
};class connectionRAII{public:connectionRAII(MYSQL **con, connection_pool *connPool);~connectionRAII();private:MYSQL *conRAII;connection_pool *poolRAII;
};#endif