Linux组件之数据库连接池

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;        // mysql的ip地址
  m_db_server_port = db_server_port;      // mysql的端口号
  m_username = username;            // mysql的用户名
  m_password = password;            // mysql的秘密
  m_db_name = db_name;            // mysql的数据库名称
  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;
  }
  int reconnect = 1;
  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;
}
// 连接池的初始化
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;
  }
  // 检查连接池池是否有空闲连接
  // 1. 连接池没有空闲连接可以用
  if (m_free_list.empty())    
  { 
    // 检查当前连接数量是否达到最大的连接数量 
    // 1.1 当前连接数 >= 最大连接数，不能创建新的连接
    if (m_db_cur_conn_cnt >= m_db_max_conn_cnt) 
    {
      // 等待的逻辑，看看是否需要超时等待
      // 1.1.1 死等，直到有连接可以用 或者 连接池要退出
      if(timeout_ms <= 0) 
      {
        log_info("wait ms:%d\n", timeout_ms);
        m_cond_var.wait(lock, [this] 
        {
          log_info("wait:%d, size:%lu\n", wait_cout++, m_free_list.size());
          // 当 (m_free_list不为空，等到了空闲连接 )或者 (请求释放连接池)，这两种情况时退出
          return (!m_free_list.empty()) | m_abort_request;
        });
      } 
      // 1.1.2 超时等待
      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:%lu\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;
      }
    }
    // 1.2 当前连接数 < 最大连接数，创建连接
    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++;
      }
    }
  }
  // 2. 连接池有空闲连接可以用
  // 获取连接
  CDBConn *pConn = m_free_list.front(); 
  // 从空闲队列删除
  m_free_list.pop_front();  
  // 加入到已经被请求的连接
  m_used_list.push_back(pConn); 
  return pConn;
}

void CDBPool::RelDBConn(CDBConn *pConn)
{ 
  if(!pConn) {
    log_error("pConn is null");
    return;
  }
  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"); // 不再次回收连接
  }
}

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

# 查看CPU信息（型号） 
cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
# 查看物理CPU个数 
cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l 
# 查看每个物理cpu核数
cat /proc/cpuinfo| grep "cpu cores"| uniq
# 查看逻辑cpu的个数 
cat /proc/cpuinfo| grep "processor"| wc -l