• mysql连接池的实现



    前言

    本文是mysql连接池的实现。学完mysql连接池之后,接下来会结合多线程来进行测试,看看使用连接池性能高,还是不要连接池性能高,具体能差多少。当然这是下一篇文章了哈哈哈哈哈。当前首要任务是学会连接池,会都不会,还用个啥哈哈哈哈。


    一、池化技术

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

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

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

    二、什么是数据库连接池

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

    大白话:创建数据库连接是一个很耗时的操作,也容易对数据库造成安全隐患。所以,在程序初始化的
    时候,集中创建多个数据库连接,并把他们集中管理,供程序使用,可以保证较快的数据库读写速度,
    还更加安全可靠。
    这里讲的数据库,不单只是指Mysql,也同样适用于Redis。

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

    资源复用:
    由于数据库连接得到复用,避免了频繁的创建、释放连接引起的性能开销,在减少系统消耗的基础
    上,另一方面也增进了系统运行环境的平稳性(减少内存碎片以及数据库临时进程/线程的数量)。

    更快的系统响应速度:
    数据库连接池在初始化过程中,往往已经创建了若干数据库连接置于池中备用。此时连接的初始化
    工作均已完成。对于业务请求处理而言,直接利用现有可用连接,避免了从数据库连接初始化和释
    放过程的开销
    ,从而缩减了系统整体响应时间。

    统一的连接管理,避免数据库连接泄露:
    在较为完备的数据库连接池实现中,可根据预先的连接占用超时设定,强制收回被占用连接。从而
    避免了常规数据库连接操作中可能出现的资源泄露。

    不使用连接池

     1. TCP建立连接的三次握手(客户端与MySQL服务器的连接基于TCP协议)
     2. MySQL认证的三次握手
     3. 真正的SQL执行
     4. MySQL的关闭
     5. TCP的四次握手关闭
    
    • 1
    • 2
    • 3
    • 4
    • 5

    可以看到,为了执行一条SQL,需要进行TCP三次握手,Mysql认证、Mysql关闭、TCP四次挥手等其他
    操作,执行SQL操作在所有的操作占比非常低
    在这里插入图片描述
    优点 :实现简单 省了连接池的设计。
    缺点:每一次发起SQL操作都经历TCP建立连接、数据库用户身份验证、数据库用户登出、TCP断开连接。

       网络IO较多
       带宽利用率低
       QPS较低
       应用频繁低创建连接和关闭连接,导致临时对象较多,带来更多的内存碎片
       在关闭连接后,会出现大量TIME_WAIT 的TCP状态(在2个MSL之后关闭)(出现大量time_wait对客户端和服务器的影响可以看以前写的全方面了解TCP的文章)
    
    • 1
    • 2
    • 3
    • 4
    • 5

    使用连接池

    第一次访问的时候,需要建立连接。 但是之后的访问,均会复用之前创建的连接,直接执行SQL语句。

    优点:

    1. 降低了网络开销
    2. 连接复用,有效减少连接数。
    3. 提升性能,避免频繁的新建连接。新建连接的开销比较大
    4. 没有TIME_WAIT状态的问题

    缺点:

    1. 设计较为复杂

    长连接和连接池的区别

    • 长连接是一些驱动、驱动框架、ORM工具的特性,由驱动来保持连接句柄的打开,以便后续的数据
      库操作可以重用连接,从而减少数据库的连接开销。
    • 而连接池是应用服务器的组件,它可以通过参数来配置连接数、连接检测、连接的生命周期等。
      连接池内的连接,其实就是长连接。

    连接池就是长连接,但是需要把长连接放到池里面去管理
    直接使用长连接的话:每个线程绑定一个连接。但是有些线程需要操作数据库,有些线程不需要操作数据库。那么在执行对应任务的时候,就需要传个参数实现,把对应的连接参数传过来,解耦性比较差。
    使用连接池的话:封装任务时候,如果要操作数据库,可以直接从连接池中获取,

    四、数据库连接池运行机制

    1. 从连接池获取或创建可用连接;
    2. 使用完毕之后,把连接返回给连接池;
    3. 在系统关闭前,断开所有连接并释放连接占用的系统资源;
      在这里插入图片描述

    五、连接池和线程池的关系

    连接池和线程池的区别

    • 线程池:主动调用任务。当任务队列不为空的时候从队列取任务取执行。
      比如去银行办理业务,窗口柜员是线程,多个窗口组成了线程池,柜员从排号队列叫号执行。
    • 连接池:被动被任务使用。当某任务需要操作数据库时,只要从连接池中取出一个连接对象,当任
      务使用完该连接对象后,将该连接对象放回到连接池中。如果连接池中没有连接对象可以用,那么
      该任务就必须等待。
      比如去银行用笔填单,笔是连接对象,我们要用笔的时候去取,用完了还回去。

    连接池和线程池设置数量的关系:

    • 一般线程池线程数量和连接池连接对象数量一致;
    • 一般线程执行任务完毕的时候归还连接对象;

    等待下一篇文章,通过线程池调用连接池来连接mysql数据库,你就会深刻感受到它们明显的区别了;

    说了这么多,终于到了连接池的设计与实现了

    六、连接池设计要点

    使用连接池需要预先建立数据库连接。
    连接池设计思路:

      1. 连接到数据库,涉及到数据库ip、端口、用户名、密码、数据库名字等;
            a. 连接的操作,每个连接对象都是独立的连接通道,它们是独立的  **(长连接)**
            b. 配置最小连接数和最大连接数       (同时并发多个线程,有的要操作数据库,有的不需要)
      2. 需要一个队列管理他的连接,比如使用list;
      3. 获取连接对象:
      4. 归还连接对象;
      5. 连接池的名字   (便于扩展,可以划分不同的数据库)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    连接池设计逻辑

    其实就是创建多个连接对象,用一个队列存起来(空闲队列),当要用连接对象操作数据库的时候,就把存起来的对象拿出来用(获取连接),并把它移除,放到存储使用对象的容器中(使用队列)。当用完它之后,就把它从使用队列中移除,放到空闲队列中,等着让其他想要操场数据库的线程接着使用,避免了频繁的创建和销毁。当系统运行完毕,把所有创建的对象统一销毁即可。

    构造函数

    设计思路图:
    在这里插入图片描述
    代码实现:

    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;
    	m_db_server_port = db_server_port;
    	m_username = username;
    	m_password = password;
    	m_db_name = db_name;
    	m_db_max_conn_cnt = max_conn_cnt;	// 
    	m_db_cur_conn_cnt = MIN_DB_CONN_CNT; // 最小连接数量
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这里插入图片描述

    初始化

    设计思路图:
    在这里插入图片描述
    代码实现:

    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);
    	}
    
    	// log_info("db pool: %s, size: %d\n", m_pool_name.c_str(), (int)m_free_list.size());
    	return 0;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    请求获取连接

    设计思路图:
    在这里插入图片描述
    代码实现:

    CDBConn *CDBPool::GetDBConn(const int timeout_ms)
    {
    	std::unique_lock<std::mutex> lock(m_mutex);
    	if(m_abort_request) 
    	{
    		log_warn("have aboort\n");
    		return NULL;
    	}
    
    	if (m_free_list.empty())		// 当没有连接可以用时
    	{
    		// 第一步先检测 当前连接数量是否达到最大的连接数量 
    		if (m_db_cur_conn_cnt >= m_db_max_conn_cnt)
    		{
    			// 如果已经到达了,看看是否需要超时等待
    			if(timeout_ms <= 0)		// 死等,直到有连接可以用 或者 连接池要退出
    			{
    				log_info("wait ms:%d\n", timeout_ms);
    				m_cond_var.wait(lock, [this] 
    				{
    					// log_info("wait:%d, size:%d\n", wait_cout++, m_free_list.size());
    					// 当前连接数量小于最大连接数量 或者请求释放连接池时退出
    					return (!m_free_list.empty()) | m_abort_request;
    				});
    			} else {
    				// return如果返回 false,继续wait(或者超时),  如果返回true退出wait
    				// 1.m_free_list不为空
    				// 2.超时退出
    				// 3. m_abort_request被置为true,要释放整个连接池
    				m_cond_var.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this] {
    					// log_info("wait_for:%d, size:%d\n", wait_cout++, m_free_list.size());
    					return (!m_free_list.empty()) | m_abort_request;
    				});
    				// 带超时功能时还要判断是否为空
    				if(m_free_list.empty()) 	// 如果连接池还是没有空闲则退出
    				{
    					return NULL;
    				}
    			}
    
    			if(m_abort_request) 
    			{
    				log_warn("have aboort\n");
    				return NULL;
    			}
    		}
    		else // 还没有到最大连接则创建连接
    		{
    			CDBConn *pDBConn = new CDBConn(this);	//新建连接
    			int ret = pDBConn->Init();
    			if (ret)
    			{
    				log_error("Init DBConnecton failed\n\n");
    				delete pDBConn;
    				return NULL;
    			}
    			else
    			{
    				m_free_list.push_back(pDBConn);
    				m_db_cur_conn_cnt++;
    				// log_info("new db connection: %s, conn_cnt: %d\n", m_pool_name.c_str(), m_db_cur_conn_cnt);
    			}
    		}
    	}
    
    	CDBConn *pConn = m_free_list.front();	// 获取连接
    	m_free_list.pop_front();	// STL 吐出连接,从空闲队列删除
    	// pConn->setCurrentTime();  // 伪代码
    	m_used_list.push_back(pConn);		// 
    
    	return pConn;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72

    这里主要说下当当前连接数为最大连接数时的两步操作。
    一共设计了两种等待方式,根据传的 计量时间(timeout_ms) 来判断,如果timeout_ms<=0,则表明我选择死等的方式,即一直阻塞等待,止到有空闲连接为止
    否则,timeout_ms>0,则表示等待阻塞这么长时间,如果超过了这么长时间,还么空闲连接,直接返回NULL即可。
    (当时我在看这部分代码的时候,一直流程图没看懂,能代码的时候,一直卧槽,怎么代码和这流程图不一样啊,一直看,一直能,终于转过这个弯来了哈哈哈哈)

    归还连接

    设计思路图:
    在这里插入图片描述
    代码实现:

    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();		// 通知取队列
    	} else 
    	{
    		log_error("RelDBConn failed\n");
    	}
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    这里notify_one()指唤醒死等阻塞和超时阻塞等待哪里
    即这里的notify_one()唤醒请求获取连接中的wait和wait_for()。这是一对。通过写博客瞬间又有了一种我懂了的感觉哈哈哈哈。复现完代码了,我还以为是唤醒多线程(线程池)那里的wait呢哈哈哈哈,浅薄了

    析构连接池

    设计思路图:
    在这里插入图片描述
    代码实现:

    // 释放连接池
    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    释放掉所有的连接对象。

    不知道你看,刚开始定义变量获取连接方法 实现的时候对bool类型的m_abort_request是否有过疑惑啊。我去这个变量是干啥的啊,有啥用啊。怎么完全看不懂啊。

    当看到这里析构函数的时候,哦是不是明白了,m_abort_request默认为false,当它为true的时候代表,连接池释放退出。哈哈哈,到这里连接池基本已经实现完成了。

    连接池基本实现。等看下一篇文章,来通过线程池任务主动通过连接池,来操作数据库,看看性能如何。
    今天时候不早了,剩下东西明天再能哈哈哈,再见各位。

    推荐一个零声学院免费公开课程,个人觉得老师讲得不错,
    分享给大家:[Linux,Nginx,ZeroMQ,MySQL,Redis,
    fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,
    TCP/IP,协程,DPDK等技术内容,点击立即学习:服务器课程

  • 相关阅读:
    基于51单片机和DHT11温湿度传感器的智能加湿器的设计与实现
    理解 React 中的 useEffect、useMemo 与 useCallback
    物联网智慧种植农业大棚系统
    一文玩转Java 泛型知识
    极智嘉(Geek+)官宣重磅合作伙伴,再度赋能仓储自动化解决方案落地
    微服务(SpringCloud)之配置管理及链路追踪
    卷积神经网络的工程技巧总结
    FANUC机器人实现本地自动运行的相关配置和参数设置
    【Newman+Jenkins】实施接口自动化测试
    金九银十!Java基础常见知识点&面试题总结(二),2022最新版!
  • 原文地址:https://blog.csdn.net/weixin_52259848/article/details/127893675