服务器编程:数据库连接池

引言：
数据库连接池和线程池的思想一样，是为了避免频繁创建和销毁数据库连接导致的性能开销。如果一个项目频繁的需要访问数据库，那么它就有可能需要频繁的创建/销毁数据库连接，那么我们可以采用数据库连接池的技术，在需要时，从数据库连接池中获取数据库连接，在用完数据库连接后再将它重新放回连接池中.

本文章所有代码大都来自开源项目：TinyWebServer

设计模式：单例模式

单例模式就是指一个类有且只能有一个实例

实现单例模式的方法：
1.定义一个静态成员变量，用来保存唯一的一个实例
2.定义一个静态成员函数，用来让其他对象可以获取到这个实例
3.将构造函数设置为私有，防止其他类进行实例化对象

单例模式的好处：
1.避免多次实例化造成的性能和资源的开销
2.共享资源，由于只有一个实例，多个对象可以共享这个实例，实现资源共享和协作

小白对单例模式的误区：
单例模式是指该类只有一个实例，这个实例是保存在类中的静态成员变量中的，因为static关键字，所以所有的对象可以共享这个实例，并通过静态成员函数获取这个实例；但是这并不代表，单例模式只能创建一个对象，单例模式是可以创建多个对象的，然后这些对象通过静态成员函数获取实例将实例赋值给自己，实现相应的操作和共享数据等功能.

一个简单的单例模式的代码：

#include 

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 

接下来将介绍几个跟数据库有关的函数：

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服务器的连接.

先只介绍这三个函数，因为我们的连接池只用这三个函数就可以实现，如果对其他函数感兴趣，可以去查找
头文件 下的常用函数

---

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::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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#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::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 
#include 
#include 
#include 
#include 
#include 
#include 
#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 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