代码编织梦想

数据库连接池的实现

1、数据库连接池

1.1、池化技术

池化技术能够减少资源对象的创建次数,提高程序的响应性能,特别是在高并发场景。使用池化技术缓存的资源对象有如下共同特点:

  • 对象创建时间长
  • 对象创建需要大量资源
  • 对象创建后可被重复使用

像常见的线程池、内存池、连接池、对象池都具有以上的共同特点。

1.2、数据库连接池

数据库连接池(Connection pooling) :是程序启动时建立足够的数据库连接,并将这些连接组成一个连接池,由程序动态地对池中的连接进行申请,使用,释放。

1.2.1、为什么使用数据库连接池

  • 资源复用:避免了连接的频繁创建和释放引起的性能开销,增加了系统运行环境的平稳性(减少内存碎片、减少临时线程的数量)
  • 高响应速度:连接池初始化后,业务请求可以直接复用现有可用连接,避免了连接创建和释放的开销,缩减了系统的整体响应时间。
  • 统一的连接管理,避免数据库连接泄漏:可根据预先的连接占用超时设定,强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄露。

不使用数据库连接池,则对于每条 sql 语句,都要执行下面流程
在这里插入图片描述
采用这样的方式,带来的问题有:

  • 带宽利用率低
  • QPS(每秒处理事务数)较低
  • 频繁创建连接和关闭连接,导致临时对象较多,带来更多的内存碎片
  • 关闭连接后,会出现大量 TIME_WAIT 状态

使用数据库连接池,初次访问,建立连接。 之后的访问复用之前的连接,直接执行 sql 语句。

在这里插入图片描述
优点

  • 降低了网络开销
  • 连接复用,有效减少连接数。
  • 提升性能,避免频繁的连接创建和释放
  • 没有TIME_WAIT状态的问题

1.2.2、长连接与连接池的区别

  • 长连接是特性,由驱动来保持连接句柄的打开,复用连接,减少数据库的连接开销。
  • 连接池是应用服务器的组件,连接池内的连接,其实就是长连接。

1.2.3、数据库连接池的运行机制

  • 从连接池获取或创建可用连接
  • 使用完毕之后,把连接归还给连接池
  • 在系统关闭前,断开所有连接并释放连接占用的系统资源

对于每个任务,核心是:获取连接 -> 操作数据库 -> 归还连接

task() {
    conn = 从连接池获取
    操作数据库
    归还 conn
}

1.2.4、连接池和线程池的区别

  • 线程池:主动操作,主动获取任务并执行
  • 连接池:被动操作,连接对象被任务获取,执行完任务后归还,内存池同理
    在这里插入图片描述

连接池和线程池设置数量关系:一般地,线程池线程数量和连接池连接对象数量一致。

2、连接池的设计

连接池设计思路:

  • 连接到数据库,涉及到数据库ip、端口、用户名、密码、数据库名字等
    • 连接的操作:每个连接对象都是长连接,相互独立
    • 配置最小连接数(一般设置为线程数)和最大连接数
  • 一个队列管理池内的连接,比如使用 list, set
  • 获取连接对象
  • 归还连接对象
  • 连接池的名字

2.1、连接池的设计逻辑

构造函数

在这里插入图片描述

初始化

构造与初始化分离,因为构造函数无返回值,可能失败的操作需要抛出异常,外部捕获。
在这里插入图片描述

请求获取连接

先判断有没有空闲连接

  • 有空闲连接,获取连接返回

  • 没有空闲连接,是否能创建新的连接

    • 能够创建新的连接,创建新的连接,获取连接返回

    • 不能创建新的连接,等待的逻辑,直到有空闲的连接可用,或连接池退出无法获取
      在这里插入图片描述

归还连接

在这里插入图片描述

析构连接池

在这里插入图片描述

2.2、mysql 连接池

构造函数

CDBPool::CDBPool(const char *pool_name, const char *db_server_ip, uint16_t db_server_port,
				 const char *username, const char *password, const char *db_name, int max_conn_cnt)
{
	m_pool_name = pool_name;				// 连接池名字
	m_db_server_ip = db_server_ip;			// mysql ip地址
	m_db_server_port = db_server_port;		// mysql 端口
	m_username = username;					// mysql 用户名
	m_password = password;					// mysql 密码
	m_db_name = db_name;					// mysql 数据库名称
	m_db_max_conn_cnt = max_conn_cnt;		// 最大连接数
	m_db_cur_conn_cnt = MIN_DB_CONN_CNT; 	// 最小连接数量
}

初始化

int CDBPool::Init() {
	// 创建固定的最小的连接数量,一个一个创建,防止创建失败
	for (int i = 0; i < m_db_cur_conn_cnt; ++i) {
		// 新建连接
		CDBConn *pDBConn = new CDBConn(this);
		// 初始化连接
		int ret = pDBConn->Init();
		if (ret) {
			delete pDBConn;
			return ret;
		}
		// 新建立的连接放入容器管理
		m_free_list.push_back(pDBConn);
	}
	return 0;
}

请求获取连接

先判断有没有空闲连接

  • 有空闲连接,获取连接返回

  • 没有空闲连接,是否能创建新的连接

    • 能够创建新的连接,创建新的连接,获取连接返回

    • 不能创建新的连接,等待,直到有空闲的连接可用,或连接池退出无法获取

CDBConn *CDBPool::GetDBConn(const int timeout_ms) {
    // 加锁
	std::unique_lock<std::mutex> lock(m_mutex); 
	
	// 是否关闭连接池,关闭则不能获取连接
	if(m_abort_request) {
		return NULL;
	}

	// 连接池是否存在可用的空闲连接?
	// 1、没有空闲连接
	if (m_free_list.empty()) {
		// 是否可以创建新的连接,即当前连接数是否达到最大连接数? 
		// 1.1、不能创建新的连接,当前连接数已经达到最大连接数
		if (m_db_cur_conn_cnt >= m_db_max_conn_cnt) {
			// 等待的逻辑,是否需要超时等待
			// 1.1.1、死等, wait,直到有空闲连接可用,或连接池要释放
			if(timeout_ms <= 0) {
				// 1. m_free_list不为空,等到了空闲连接,
				// 2. 或者请求释放连接池(否则无法退出)
				m_cond_var.wait(lock, [this] {
					return (!m_free_list.empty()) | m_abort_request;
				});
			}
			// 1.1.2、超时等待, wait for
             // 直到有空闲连接可用,或超时退出,或连接池要释放 
			else {
				// 1.m_free_list不为空,等到了空闲连接
				// 2.超时退出
				// 3. m_abort_request被置为true,要释放整个连接池
				m_cond_var.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this] {
					return (!m_free_list.empty()) | m_abort_request;
				});

				// 如果没有等到空闲连接
				if(m_free_list.empty()) {
					return NULL;
				}
			}

			// 若连接池要释放,则不能获取资源
			if(m_abort_request) {
				return NULL;
			}
		}
		// 1.2、可以创建新的连接,当前连接数未达到最大连接数
		else {
			//建立新的连接
			CDBConn *pDBConn = new CDBConn(this);	
			int ret = pDBConn->Init();
			if (ret) {
				delete pDBConn;
				return NULL;
			}
			else {
				m_free_list.push_back(pDBConn);
				m_db_cur_conn_cnt++;
			}
		}
	}

	// 2、存在空闲连接
	// 获取连接
	CDBConn *pConn = m_free_list.front();	
	// 从空闲队列删除
	m_free_list.pop_front();	
	// 加入到已经被请求的连接
	m_used_list.push_back(pConn); 

	return pConn;
}

归还连接

void CDBPool::RelDBConn(CDBConn *pConn) {
	std::lock_guard<std::mutex> lock(m_mutex);

	list<CDBConn *>::iterator it = m_free_list.begin();
	
	// 检测该连接是否已经归还,避免重复归还
	for (; it != m_free_list.end(); it++) {
		if (*it == pConn) {
			break;
		}
	}

	// 还没有归还,插入空闲队列并通知取队列
	if (it == m_free_list.end()) {
		m_used_list.remove(pConn);
		m_free_list.push_back(pConn);
		m_cond_var.notify_one();	
	} 
}

析构连接池

CDBPool::~CDBPool() {
	std::lock_guard<std::mutex> lock(m_mutex);
	// 设置关闭标记 
	m_abort_request = true;  
	// 通知所有在等待的请求退出
	m_cond_var.notify_all(); 

	for (list<CDBConn *>::iterator it = m_free_list.begin(); it != m_free_list.end(); it++){
		CDBConn *pConn = *it;
		delete pConn;
	}

	m_free_list.clear();
}

常见问题

问题1:too many connections

首先登录mysql终端,查看最大连接数。

show variables like '%max_connection%';

临时修改默认连接数

set GLOBAL max_connections=1000;

问题2:Your password does not satisfy the current policy requirements

重新设置密码表的级别

SHOW VARIABLES LIKE 'validate_password%';
set global validate_password_length=6;
set global validate_password_policy=0;

问题3:Access denied for user ‘root’@‘localhost’,

没有设置对应用户的权限

# 查找 mysql.user 中的用户
SELECT `user`,`host`,`authentication_string`,`plugin` FROM mysql.user;
# 创建远程连接的用户
CREATE USER 'root'@'%' IDENTIFIED BY '123456';
GRANT ALL ON maindataplus.* TO 'root'@'%';
flush privileges;
# 修改本地连接用户的密码
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';
flush privileges;

2.3、redis 连接池

构造函数

CachePool::CachePool(const char *pool_name, const char *server_ip, int server_port, int db_index,
					 const char *password, int max_conn_cnt)
{
	m_pool_name = pool_name;
	m_server_ip = server_ip;
	m_server_port = server_port;
	m_db_index = db_index;
	m_password = password;
	m_max_conn_cnt = max_conn_cnt;
	m_cur_conn_cnt = MIN_CACHE_CONN_CNT;
}

初始化

int CachePool::Init()
{
	// 创建最小的连接数量
	for (int i = 0; i < m_cur_conn_cnt; i++)
	{
		// 新建连接
		CacheConn *pConn = new CacheConn(m_server_ip.c_str(), m_server_port,
										 m_db_index, m_password.c_str(), m_pool_name.c_str());
		// 初始化连接
		if (pConn->Init())
		{
			delete pConn;
			return 1;
		}

		// 新建立的连接放入容器管理
		m_free_list.push_back(pConn);
	}

	return 0;
}

请求获取连接

CacheConn *CachePool::GetCacheConn() {
	m_free_notify.Lock();

	// 连接池是否存在可用的空闲连接
	// 1、没有空闲连接
	while (m_free_list.empty()) {
		// 能否创建新的连接,当前连接数量是否已经达到最大连接数量
		// 1.1、不能创建新的连接,当前连接数量已经达到最大连接数量
		if (m_cur_conn_cnt >= m_max_conn_cnt) {
			// 等待空闲连接可用
			m_free_notify.Wait();
		}
		// 1.2、可以创建新的连接,当前连接数未达到最大连接数
		else {
			// 创建新的连接
			CacheConn *p_cache_conn = new CacheConn(m_server_ip.c_str(), m_server_port,
													m_db_index, m_password.c_str(), m_pool_name.c_str());
			int ret = p_cache_conn->Init();
			if (ret) {
				delete p_cache_conn;
				m_free_notify.Unlock();
				return NULL;
			}
			else {
				m_free_list.push_back(p_cache_conn);
				m_cur_conn_cnt++;
			}
		}
	}

	// 2、存在空闲连接
	// 获取空闲连接
	CacheConn *pConn = m_free_list.front();
	// 从空闲队列中删除
	m_free_list.pop_front();
	
	m_free_notify.Unlock();
	
	return pConn;
}

归还连接

void CachePool::RelCacheConn(CacheConn *p_cache_conn) {
	m_free_notify.Lock();

	list<CacheConn *>::iterator it = m_free_list.begin();
	
	// 检测该连接是否已经归还,避免重复归还
	for (; it != m_free_list.end(); it++) {
		if (*it == p_cache_conn) {
			break;
		}
	}
	// 还没有归还,插入空闲队列并通知取队列
	if (it == m_free_list.end()) {
		m_free_list.push_back(p_cache_conn);
	}

	m_free_notify.Signal();
	m_free_notify.Unlock();
}

析构连接池

CachePool::~CachePool() {
	m_free_notify.Lock();
	for (list<CacheConn *>::iterator it = m_free_list.begin(); it != m_free_list.end(); it++) {
		CacheConn *pConn = *it;
		delete pConn;
	}

	m_free_list.clear();
	m_cur_conn_cnt = 0;
	m_free_notify.Unlock();
}

3、连接池连接数量设置

经验公式:连接数 = ((cpu核心数 * 2) + 有效磁盘数)

# 查看CPU信息(型号) 
cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
# 查看物理CPU个数 
cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l 
# 查看每个物理cpu核数
cat /proc/cpuinfo| grep "cpu cores"| uniq
# 查看逻辑cpu的个数 
cat /proc/cpuinfo| grep "processor"| wc -l 

io 密集型任务:设置 cpu 利用率倒数个数的线程数和连接数

4、参考

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/you_fathe/article/details/127152610

java数据库连接池实现原理-爱代码爱编程

一般来说,Java应用程序访问数据库的过程是:   ①装载数据库驱动程序;   ②通过jdbc建立数据库连接;   ③访问数据库,执行sql语句;   ④断开数据库连接。 public class DBConnection { private Connection con; //定义数据库连接类对象 private PreparedS

php - 数据库连接池实现_倾听岁月的博客-爱代码爱编程_php 连接池

什么是数据库连接池? 数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个;释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。

基于java演唱会购票系统计算机毕业设计源码+系统+数据库+lw文档+部署_ssh 演唱会门票预约管理系统-爱代码爱编程

基于JAVA演唱会购票系统计算机毕业设计源码+系统+数据库+lw文档+部署 基于JAVA演唱会购票系统计算机毕业设计源码+系统+数据库+lw文档+部署 本源码技术栈: 项目架构:B/S架构 开发语言:Java语言 开发软件:idea eclipse 前端技术:Layui、HTML、CSS、JS、JQuery等技术 后端技术

pycharm连接远程数据库_pycharm连接clickhouse-爱代码爱编程

创建连接 首先我们需要点击Database,创建所需的数据库连接(这里使用PostgreSQL做演示)。 配置SSH信息 随后在弹出的窗口中选择SSH/SSL一栏,勾选User SSH tunnel 点击小省略号