连接池技术：简单而强大的加速数据库访问方法

sudo apt-get install mysql-server

# 切换系统账户，$
sudo su
# 进入mysql,#
mysql
# 查看用户表，mysql> 
select user, plugin from mysql.user;
# 修改root密码，mysql> 
update mysql.user set authentication_string=PASSWORD('123456'), plugin='mysql_native_password' where user='root';
# 刷新，mysql> 
flush privileges;
# 退出mysql，mysql> 
exit
# 重启服务,#
service mysql restart

sudo apt-get install libmysqlclient-dev

# 创建mysql_pool_test的数据库，mysql>
create database mysql_pool_test;
# 查看所有数据库，mysql>
show databases;

# 查看最大连接数。mysql>
show variables like "max_connections";
# 结果显示如下：
# mysql> show variables like "max_connections";                                   
# +-----------------+-------+
# | Variable_name   | Value |
# +-----------------+-------+
# | max_connections | 151   |
# +-----------------+-------+
# 1 row in set (0.00 sec)
#
# 默认连接数量这里只有151，可以根据自己需要修改。比如可以临时设置为1000
set GLOBAL max_connections=1000;

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; // 最小连接数量
}

// 连接对象初始化
int CDBConn::Init()
{
  m_mysql = mysql_init(NULL); // mysql_标准的mysql c client对应的api
  if (!m_mysql)
  {
    log_error("mysql_init failed\n");
    return 1;
  }
  my_bool reconnect = true;
  mysql_options(m_mysql, MYSQL_OPT_RECONNECT, &reconnect);  // 配合mysql_ping实现自动重连
  mysql_options(m_mysql, MYSQL_SET_CHARSET_NAME, "utf8mb4");  // 设置字符集，utf8mb4和utf8区别
  // ip 端口 用户名 密码 数据库名
  if (!mysql_real_connect(m_mysql, m_pDBPool->GetDBServerIP(), m_pDBPool->GetUsername(), m_pDBPool->GetPasswrod(),
              m_pDBPool->GetDBName(), m_pDBPool->GetDBServerPort(), NULL, 0))
  {
    log_error("mysql_real_connect failed: %s\n", mysql_error(m_mysql));
    return 2;
  }
  return 0;
}
// 连接对象的构造函数
CDBConn::CDBConn(CDBPool *pPool)
{
  m_pDBPool = pPool;
  m_mysql = NULL;
}
// 连接对象的析构函数
CDBConn::~CDBConn()
{
  if (m_mysql)
  {
    mysql_close(m_mysql);
  }
}
// ......
// pool 初始化
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;
}

/*
 *TODO: 增加保护机制，把分配的连接加入另一个队列，这样获取连接时，如果没有空闲连接，
 *TODO: 检查已经分配的连接多久没有返回，如果超过一定时间，则自动收回连接，放在用户忘了调用释放连接的接口
 * timeout_ms默认为 0死等
 * timeout_ms >0 则为等待的时间
 */
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] 
        {
          // 当前连接数量小于最大连接数量 或者请求释放连接池时退出
          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++;
      }
    }
  }
  CDBConn *pConn = m_free_list.front(); // 获取连接
  m_free_list.pop_front();  // STL 吐出连接，从空闲队列删除
  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_free_list.push_back(pConn);
    m_cond_var.notify_one();    // 通知取队列
  } else 
  {
    log_error("RelDBConn failed\n");
  }
}

// 释放连接池
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();
}

my_bool reconnect = true;
mysql_options(m_mysql, MYSQL_OPT_RECONNECT, &reconnect);  // 配合mysql_ping实现自动重连

int STDCALL mysql_ping(MYSQL *mysql);