基于C++实现Mysql数据库连接池实例

窗火=

1. 
   
2. 数据库连接池负责分配、管理、和释放数据库连接，允许使用应用程序重复使用一个现有的数据库连接。数据库连接是关键有限且昂贵的资源，一个数据库连接对象均对应一个物理数据库的连接，每次操作都打开一个物理连接，使用完都关闭连接.
   
3. 
   
4. 基于C++实现Mysql数据库连接池实例
   
5. 
   
6. 项目技术点
   
7. C语言进行MYSQL数据库编程
   
8. 无锁单例
   
9. 基于STL队列加C++11新特性保证线程安全实现的生产者消费者模型
   
10. C++11多线程编程 (线程间同步与互斥)
    
11. 基于CAS的原子整形
    
12. lambda表达式
    
13. shared_ptr智能指针管理Connection*指针对象
    
14. 基于C++11标准库实现, 具备跨平台的特性，省去了对于pthread库的C++的封装.更加针对于项目的核心逻辑上的思考和实现. (主干到细节)
    
15. Makefile自动化编译
    
16. 项目意义
    
17. 高并发场景下, 频繁创建, 销毁连接带来的性能损耗
    
18. 
    
19. 三次握手，连接认证(身份权限认证)，MySQL资源释放, 四次挥手
    
20. 
    
21. 每一次client 访问 Mysql server都需要进行上述操作. 上述这些操作是固定的流程. 真正的sql语句执行操作才是我们无法逃脱的, 所以上述这些我们完全可以提前创建出来，然后进行不断的复用connections. 实现mysql server访问的性能提升.
    
22. 
    
23. 思考: 提前创建好的 connetions 数目是否是越多越好？
    
24. 
    
25. 当然是不可能，因为每一个connection都是需要占据一定的系统资源的, 创建过多的connection 会导致服务器资源紧张. 起码per connection per socketfd (套接字资源)
    
26. 
    
27. 思考: connections 数目设计?
    
28. 
    
29. 上下限限制数目. initSize控制下限. maxSize控制连接上限 （一般是系统的最大mysql connetions num）
    
30. 
    
31. 多余connection最长闲置时间限制： maxIdleTime （及时释放闲置连接）
    
32. 
    
33. 资源紧张, 并发访问量高. 没有连接可用 ：connectionTimeout (return error, 获取连接超时时间)
    
34. 
    
35. 项目实现
    
36. Connection设计
    
37. 数据成员
    
38. 
    
39. MYSQL* _conn; //连接句柄  
    
40. clock_t _startTime;   //连接起始空闲时间
    
41. 操作接口
    
42. 
    
43. Connection();//构造 init Connection
    
44. ~Connection();   //析构 destroy connection
    
45. bool connect(ip, port, username, password, dbname); //连接操作， 返回连接结果
    
46. bool update(sql);//表更新操作, 返回更新结果
    
47. MYSQL_RES* query(sql);   //查询操作, 返回查询结果
    
48. void refreshStartTime(); //刷新连接起始空闲时间
    
49. clock_t getAliveTime();  //获取连接空闲时间
    
50. ConnectionPool设计
    
51. 数据成员
    
52. 
    
53. //连接登录信息
    
54. string _ip;
    
55. unsigned short _port;
    
56. string _username;
    
57. string _password;
    
58. string _dbname;
    
59. //连接数量等配置信息
    
60. int _initSize;
    
61. int _maxSize;
    
62. int _maxIdleTime;
    
63. int _connectionTimeout;
    
64. //连接存储信息，以及保证线程安全
    
65. queue<Connection*> _connectionQue;
    
66. mutex _queueLock;
    
67. condition_variable _cond;
    
68. atomic_int _connectionCnt;
    
69. 操作接口
    
70. 
    
71. ConnectionPool();  //构造 init pool, 加载配置, 初始连接, 启动线程
    
72. static ConnectionPool* getConnectionPool();//获取单例
    
73. shared_ptr<Connection> getConnection();//获取连接
    
74. int _loadConfigFile(string& filename); //加载解析配置信息
    
75. void produceConnectionTask();  //生产连接任务
    
76. void scannerConnetionTask();   //扫描监视销毁空闲线程任务
    
77. 项目复杂接口细节刨析
    
78. getConnection()
    
79. 
    
80. /*
    
81. 从连接池中获取一条连接. 相当于是消费者
    
82. 消费前提, _connectionQue中有货, 所以无货期间需要进行阻塞休眠等待.
    
83. 等待也不能一直等待. 存在连接超时时间,
    
84. waittime >= _connectionTimeout then output << error.
    
85. */
    
86. shared_ptr<Connection> getConnection() {
    
87. unique_lock<mutex> auto_lock(_queueLock);//定义智能锁
    
88. while (_connectionQue.empty()) {
    
89. if (cv_status::timeout == _cond.wait_for(auto_lock,  chrono::milliseconds(_connectionTimeout))) { //达到连接超时时间
    
90. if (_connectionQue.empty()) {
    
91. //LOG DEBUG INFO
    
92. cerr << "获取连接超时" << endl;
    
93. return nullptr;
    
94. }
    
95. }
    
96. }
    
97. //定义shared_ptr<Connection> 自定义del函数, 而非直接调用~T()
    
98. shared_ptr<Connection> sp(_connectionQue.front(), [&](Connection* pconn){
    
99. unique_lock<mutex> auto_lock(_queueLock);
    
100. pconn->refreshStartTime();  //刷新连接起始空闲时间
     
101. _connectionQue.push(pconn);
     
102. });
     
103. _connectionQue.pop();
     
104. _cond.notify_all(); //弹出任务, queue maybe empty notify produce
     
105. return sp;
     
106. }
     
107. produceConnectionTask()
     
108. 
     
109. /*
     
110. 生产者线程任务. 在_connectionQue中无connetion
     
111. && _connectionCnt < _maxSize 时候 及时创建连接填充_connectionQue。   
     
112. */
     
113. void produceConnectionTask() {
     
114. for (;;) {
     
115. unique_lock<mutex> auto_lock(_queueLock);
     
116. while (!_connectionQue.empty()) {
     
117. _cond.wait(auto_lock);
     
118. }
     
119. if (_connectionCnt < _maxSize) {
     
120. Connection* pconn = new Connection();
     
121. pconn->connet(_ip, _port, _username, _password, _dbname);
     
122. pconn->refreshStartTime();
     
123. _connectionQue.push(pconn);
     
124. _connectionCnt++;
     
125. }
     
126. _cond.notify_all(); //通知消费
     
127. }
     
128. }
     
129. ​
     
130. scannerConnetionTask()
     
131. 
     
132. /*
     
133.         不停的扫描所有的connection, 从头到尾的扫描,
     
134. 监控销毁哪些长期空闲的connection, 避免对于空闲资源的无端占用浪费.  
     
135. 每一次休眠一个 _maxIdleTime 就出来 检查, 定期轮询检查空闲丽连接进行销毁
     
136. */
     
137. void scannerConnectionTask() {
     
138. for (;;) {
     
139. //休眠maxIdleTime
     
140.         this_thread::sleep_for(chrono::seconds(_maxIdleTime));   
     
141. unique_lock<mutex> auto_lock(_queueLock);
     
142. while (_connectionCnt > _initSize)
     
143.                 {
     
144.                         Connection *p = _connectionQue.front();
     
145.                         if (p->getAliveeTime()/SECONDS_PER_SEC >= _maxIdleTime)
     
146.                         {
     
147.                                 _connectionQue.pop();
     
148.                                 _connectionCnt--;
     
149.                                 delete p; // 调用~Connection()释放连接
     
150.                         }
     
151.                         else
     
152.                         {
     
153.                                 break; // 队头的连接没有超过_maxIdleTime，其它连接肯定没有
     
154.                         }
     
155.                 }   
     
156. }
     
157. }

复制代码