池式组件-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;
  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 CDBPool::Init()
{
  // 创建固定最小的连接数量
  for (int i = 0; i < m_db_cur_conn_cnt; i++)//创建最小连接数个连接放入，空闲队列free_list中 
  {
    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;
}

/*
 *TODO: 增加保护机制，把分配的连接加入另一个队列，这样获取连接时，如果没有空闲连接，
 *TODO: 检查已经分配的连接多久没有返回，如果超过一定时间，则自动收回连接，放在用户忘了调用释放连接的接口
 * timeout_ms默认为 0死等
 * timeout_ms >0 则为等待的时间
 */
int wait_cout = 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] 
        {
          // 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;//返回 连接 
}

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
    {
      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");
  }
}
// 遍历检测是否超时未归还
// pConn->isTimeout(); // 当前时间 - 被请求的时间
// 强制回收  从m_used_list 放回 m_free_list

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();
}

GetConn("聊天消息连接池")
GetConn("用户信息连接池 ")；

string CacheConn::get(string key)
{
  string value;
  if(Init())
  {
    return value;
  }
}