MySQL数据库编程，单例模式，queue队列容器、C 11多线程编程、线程互斥、线程同步通信(mutex、条件变量)和 unique_lock、基于CAS原子整形、智能指针shared_ptr、lambda生产者-消费者线程模型

为了提高MySQL数据库(基于C/S除了在服务器端增加缓存服务器缓存常用数据外，访问瓶颈的设计) 之外（例如redis），还可以增加连接池来改进MySQL Server访问效率，在高并发条件下，大量 TCP三次握手、MySQL Server连接认证、MySQL Server关闭连接回收资源和TCP四次挥手的费用 性能时间也很明显，增加连接池是为了减少这部分的性能损失。

这个项目是为了在那里C/C 在项目中，提供MySQL Server基于访问效率的实现C 数据库连接池模块的代码。

连接池一般包含用于数据库连接的内容ip地址、port端口号、用户名、密码等性能参数，如初始 本项目基于初始连接量、最大连接量、最大空闲时间、连接超时时间等C 语言实现的主要连接池 它还实现了上述所有连接池支持的通用基本功能。

初始连接量（initSize）：表示连接池会提前和解MySQL Server创建initSize个数的connection连接，当 应用发起MySQL访问时，无需创建和MySQL Server新的连接直接从连接池中获得可用的连接 就可以，使用完成后，并不去释放connection，而是把当前connection返回连接池。

最大连接量（maxSize）：当并发访问MySQL Server当要求增加时，初始连接量不足以使用。 应用程序将根据新的要求数量创建更多的连接，但新创建的连接数量的上限是maxSize，不能 无限创建连接，因为每个连接都占用一个socket资源，一般连接池和服务器程序部署在一个 主机上的，如果连接池占用过多socket服务器无法接受太多的客户端请求。当这些连 连接完成后，返回连接池进行维护。

最大的空闲时间（maxIdleTime）：当访问MySQL并发请求增加后，连接池中的连接数量将动态 增加，上限是maxSize当这些连接用完后，再返回连接池。若指定maxIdleTime里面， 这些新增加的连接还没有再次使用，所以新增加的连接资源将被回收，只需要保持初始连接 接量initSize连接就够了。

连接超时间（connectionTimeout）：当MySQL并发请求量过大，连接池中的连接量已达到 maxSize此时，没有空闲连接可供使用，因此从连接池获取连接的应用程序不能成功，它通过阻塞 的方式获取连接的时间如果超过connectionTimeout时间，连接失败，无法访问数据库。 本项目主要实现上述连接池的四个功能，其他连接池可自行实现更多的扩展功能。

mysql函数api_MySQL API函数

MySQL 5.7 C API开发人员指南

mysql> show variables like ‘max_connections’; 可以查看命令MySQL Server支持的最大连接数超过max_connections数量连接，MySQL Server会直接拒绝，所以当使用连接池来增加连接数量时，MySQL Server的max_connections参数 还应适当调整连接池的连接上限。

ConnectionPool.cpp和ConnectionPool.h：实现连接池代码

Connection.cpp和Connection.h：实现数据库操作代码的增删和查看代码

连接池主要包含以下功能点：

1.连接池只需要一个例子，所以ConnectionPool以单例模式设计

2.从ConnectionPool中可以获取和MySQL的连接Connection

6个函数是主要功能 获取实例，加载配置项，构造函数， 生产线程(连接用完后补充)、消费者(接口)、定时线程(回收资源)

// 连接池的结构 ConnectionPoo::ConnectionPool()
{
	// 加载配置项了
	if (!loadConfigFile())
	{
		return;
	}

	// 创建初始数量的连接
	for (int i = 0; i < _initSize; ++i)
	{
		Connection* p = new Connection();
		p->connect(_ip, _port, _username, _password, _dbname);
		p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
		_connectionQue.push(p);
		_connectionCnt++;
	}

	// 启动一个新的线程，作为连接的生产者 linux thread => pthread_create
	thread produce(std::bind(&ConnectionPool::produceConnectionTask, this));
	produce.detach();

	// 启动一个新的定时线程，扫描超过maxIdleTime时间的空闲连接，进行对于的连接回收
	thread scanner(std::bind(&ConnectionPool::scannerConnectionTask, this));
	scanner.detach();
}

// 线程安全的懒汉单例函数接口 调用的时候再构造
ConnectionPool* ConnectionPool::getConnectionPool()
{
	static ConnectionPool pool; // lock和unlock
	return &pool;
}

// 运行在独立的线程中，专门负责生产新连接
void ConnectionPool::produceConnectionTask()
{
	for (;;)
	{
		unique_lock<mutex> lock(_queueMutex);
		while (!_connectionQue.empty())
		{
			cv.wait(lock); // 队列不空，此处生产线程进入等待状态，释放锁
		}

		// 连接数量没有到达上限，继续创建新的连接
		if (_connectionCnt < _maxSize)
		{
			Connection* p = new Connection();
			p->connect(_ip, _port, _username, _password, _dbname);
			p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
			_connectionQue.push(p);
			_connectionCnt++;
		}

		// 通知消费者线程，可以消费连接了
		cv.notify_all();
	}
}

// 给外部提供接口，从连接池中获取一个可用的空闲连接
shared_ptr<Connection> ConnectionPool::getConnection()
{
	unique_lock<mutex> lock(_queueMutex);
	while (_connectionQue.empty())
	{
		// sleep
		if (cv_status::timeout == cv.wait_for(lock, chrono::milliseconds(_connectionTimeout)))
		{
			if (_connectionQue.empty())
			{
				LOG("获取空闲连接超时了...获取连接失败!");
				return nullptr;
			}
		}
	}

	/*
	shared_ptr智能指针析构时，会把connection资源直接delete掉，相当于
	调用connection的析构函数，connection就被close掉了。
	这里需要自定义shared_ptr的释放资源的方式，把connection直接归还到queue当中
	*/
	shared_ptr<Connection> sp(_connectionQue.front(),
		[&](Connection* pcon) {
			// 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
			unique_lock<mutex> lock(_queueMutex);
			pcon->refreshAliveTime(); // 刷新一下开始空闲的起始时间
			_connectionQue.push(pcon);
		});

	_connectionQue.pop();
	cv.notify_all();  // 消费完连接以后，通知生产者线程检查一下，如果队列为空了，赶紧生产连接

	return sp;
}

// 扫描超过maxIdleTime时间的空闲连接，进行对于的连接回收
void ConnectionPool::scannerConnectionTask()
{
	for (;;)
	{
		// 通过sleep模拟定时效果
		this_thread::sleep_for(chrono::seconds(_maxIdleTime));

		// 扫描整个队列，释放多余的连接
		unique_lock<mutex> lock(_queueMutex);
		while (_connectionCnt > _initSize)
		{
			Connection* p = _connectionQue.front();
			if (p->getAliveTime() >= (_maxIdleTime * 1000))
			{
				_connectionQue.pop();
				_connectionCnt--;
				delete p; // 调用~Connection()释放连接
			}
			else
			{
				break; // 队头的连接没有超过_maxIdleTime，其它连接肯定没有
			}
		}
	}
}

开发平台选型

有关MySQL数据库编程、多线程编程、线程互斥和同步通信操作、智能指针、设计模式、容器等等这些 技术在C++语言层面都可以直接实现，因此该项目选择直接在windows平台上进行开发，当然放在 Linux平台下用g++也可以直接编译运行。

验证数据的插入操作所花费的时间，第一次测试使用普通的数据库访问操作，第二次测试使用带连接池 的数据库访问操作，对比两次操作同样数据量所花费的时间，性能压力测试结果如下（电脑配置不太高——Intel® Core™ i5-8300H CPU @ 2.30GHz 2.30 GHz）；

(不同电脑的降低比率不同)

• 依赖关系

#数据库连接池的配置文件
ip=127.0.0.1
port=3306
username=root
password=12345678
dbname=chat
initSize=10
maxSize=1024
#最大空闲时间默认单位是秒
maxIdleTime=60
#连接超时时间单位是毫秒
connectionTimeOut=100

CREATE DATABASE chart;

CREATE TABLE IF NOT EXISTS `user`(
   `id` INT(11) UNSIGNED AUTO_INCREMENT,
   `name` VARCHAR(50),
   `age` VARCHAR(11),
   `sex` enum('male', 'female'),
   PRIMARY KEY ( `id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

#define _CRT_SECURE_NO_WARNINGS

#include "pch.h"
#include <iostream>
using namespace std;
#include "Connection.h"
#include "CommonConnectionPool.h"

void f() {
	ConnectionPool *cp = ConnectionPool::getConnectionPool();
	for (int i = 0; i < 5000; ++i)
	{
		char sql[1024] = { 0 };
		sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
			"zhang san", 20, "male");
		shared_ptr<Connection> sp = cp->getConnection();
		sp->update(sql);
		/*Connection conn;
		char sql[1024] = { 0 };
		sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
			"zhang san", 20, "male");
		conn.connect("127.0.0.1", 3306, "root", "12345678", "chat");
		conn.update(sql);*/
	}
}

int main()
{
	// Connection conn;
	// conn.connect("127.0.0.1", 3306, "root", "12345678", "chat");
#if 1
	clock_t begin = clock();
	f();
	clock_t end = clock();
	std::cout << (end - begin) << "ms" << endl;
#endif

#if 1

	clock_t begin4 = clock();
	thread t1(f);
	thread t2(f);
	thread t3(f);
	thread t4(f);

	t1.join();
	t2.join();
	t3.join();
	t4.join();

	clock_t end4 = clock();
	std::cout << (end4 - begin4) << "ms" << endl;
#endif



	return 0;
}

懒汉式单例类.在第一次调用的时候实例化自己 ！ 饿汉式单例类.在类初始化时，已经自行实例化 单例模式 Singleton 就是保证一个类只有一个实例

#include "pch.h"
#include "public.h"
#include "Connection.h"
#include <iostream>
using namespace std;

Connection::Connection()
{
	// 初始化数据库连接
	_conn = mysql_init(nullptr);
}

Connection::~Connection()
{
	// 释放数据库连接资源
	if (_conn != nullptr)
		mysql_close(_conn);
}

bool Connection::connect(string ip, unsigned short port,
	string username, string password, string dbname)
{
	// 连接数据库
	MYSQL* p = mysql_real_connect(_conn, ip.c_str(), username.c_str(),
		password.c_str(), dbname.c_str(), port, nullptr, 0);
	return p != nullptr;
}

bool Connection::update(string sql)
{
	// 更新操作 insert、delete、update
	if (mysql_query(_conn, sql.c_str()))
	{
		LOG("更新失败:" + sql);
		return false;
	}
	return true;
}

MYSQL_RES* Connection::query(string sql)
{
	// 查询操作 select
	if (mysql_query(_conn, sql.c_str()))
	{
		LOG("查询失败:" + sql);
		return nullptr;
	}
	return mysql_use_result(_conn);
}

// Connection.h
#pragma once
#include <string>
#include <queue>
#include <mutex>
#include <iostream>
#include <atomic>
#include <thread>
#include <condition_variable>
#include <memory>
#include <functional>
using namespace std;
#include "Connection.h"

class ConnectionPool
{
public:
    static ConnectionPool* getConnectionPool();
    shared_ptr<Connection> getConnection();
    
private:
    ConnectionPool();
    bool loadConfigFile();
    void produceConnectionTask();
    void scannerConnectionTalk();
    
    string _ip;
    unsigned short __port;
    string _username;
    string _dbname;
    int _initsize;
    int _maxsize;
    int _maxIdleTime;
    int _connectionTimeout;
    
    queue<Connection*> _connectionQue;
    mutex _queueMutex;
    atmoix_int _connectionCnt;
    condition_variable cv;
}

// ConnectionPool.cpp  函数实现

#include "pch.h"
#include "CommonConnectionPool.h"
#include "public.h"

ConnectionPool* ConnectionPool::getConnectionPool()
{
    statuc ConnectionPool pool;
    return &pool;
}

bool ConnectionPool::loadConfigFile()
{
    FILE* pf = fopen("mysql.ini", "r");
    if (pf == nullptr)
    {
        LOG("mysql.ini file dose not exsit!");
        return false;
    }
    
    while (!feof(pf)) 
    {
    	char line[1024] = { 0 };
        fgets(line, 1024, pf);
        string str = line;
        int idx = str.find('=', 0);
        if (idx == -1) // 无效的配置项
        {
            continue;
        }
        
        int endidx = str.find('\n', idx);
        string key = str.substr(0, idx);
        string value = str.substr(idx + 1, endidx - idx - 1);
        
        if (key == "ip")
        {
            _ip = value;
        }
        else if (key == "port")
        {
            _port = atoi(value.c_str());
        }
        else if (key == "password")
        {
            _password = value;
        }
        else if (key = "dbname") 
        {
            _dbname = value;
        }
        else if (key == "initSize")
        {
            _initSize = atoi(value.c_str());
        }
        else if (key == "maxSize")
        {
            _maxSize = atoi(value.c_str());
        }
        else if (key == "maxIdleTime")
		{
			_maxIdleTime = atoi(value.c_str());
		}
		else if (key == "connectionTimeOut")
		{
			_connectionTimeout = atoi(value.c_str());
		}
    }
    return true;
}

ConnectionPool::ConnetionPool()
{
    if (!loadConfigFile())
    {
        return ;
    }
    
    for (int i = 0; i < _initSize; ++i)
    {
        Connection* p = new Connection();
        p->connect(_ip, port, _username, _password, _dbname);
        p->refreshAliveTime();
        _connectionQue.push(p);
        _connectionCnt++;
    }
    
    thread produce(std::bind(&ConnectionPool::produceConnectionTask, this));
    produce.detach();
    
    thread scanner(std::bind(&ConnectionPool::scannerConnectionTask, this));
    scanner.detach();
}

void ConnectionPool::produceConnectionTask()
{
    for (;;)
    {
        unique_lock<mutex> lock(_queueMutex);
        while (!_connectionQue.empty())
        {
            cv.wait(lock);
        }
        
        if (_connection < _maxSize)
        {
            Connection* p = new Conncetion();
            p->connect(_ip, _port, _username, _password, _dbname);
            p->refershAlibeTime();
            _connectionQue,push(p);
            _connectionCnt++;
        }
        
        cv.notify_all();
    }
}

shared_ptr<Connection> ConnectionPool::getConnection()
{
    unique_lock<mutex> lock(_queueMutex);
    while (_connectionQue.empty())
    {
        if (cv_status::timeout == cv.wait_for(lock, chrono::milliseconds(_connecionTimeout)))
        {
            if (_connectionQue.empty())
            {
                LOG("获取空闲连接超时了...获取连接失败！")；
                return nullptr;
            }
        }
    }
    
    shared_ptr<Connection> sp(_conncetionQue.front(),
          [&](Connection* pcon) {
              unique_lock<mutex> lock(_queMutex);
              pcon->refershAliveTime();
              _connectionQue.push(pcon);
          });
    
    _connecitonQue.pop();
    cv.notify_all();
    
    return sp;
}

void ConnectionPool::scannerConnectionTask()
{
    for (;;)
    {
        this_thread::sleep_for(chrono::seconds(maxIdleTime));
        
        unique_lock<mutex> lock(_queueMutex);
        while (_connectionCnt > _initSize)
        {
            Connection* p = _connectionQue.front();
            if (p->getAliveTime() >= (_maxIdleTime * 1000))
            {
                _connectionQue.pop();
                _conectionCnt--;
                delete p;
            }
            else 
            {
                break;
            }
        }
    }
}