1. TCP建立连接的三次握手
2. MySQL认证的三次握手
3. 真正的SQL执行
4. MySQL的关闭
5. TCP的四次握手关闭

网络IO较多
带宽利用率低
QPS较低
应用频繁低创建连接和关闭连接，导致临时对象较多，带来更多的内存碎片
在关闭连接后，会出现大量TIME_WAIT 的TCP状态（在2个MSL之后关闭）

1. 连接到数据库，涉及到数据库ip、端口、用户名、密码、数据库名字等；
  a. 连接的操作，每个连接对象都是独立的连接通道，它们是独立的
  b. 配置最小连接数和最大连接数
2. 需要一个队列管理他的连接，比如使用list；
3. 获取连接对象：
4. 归还连接对象；
5. 连接池的名字

CDBPool *pDBPool = new CDBPool(db_pool_name, db_host, db_port,db_username, db_password, db_dbname, db_maxconncnt);


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

if (pDBPool->Init()) {
  printf("init db instance failed: %s", db_pool_name);
  return -1;
}
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;
}

CDBConn *pDBConn = pDBPool->GetDBConn(); // 获取连接


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 吐出连接，从空闲队列删除
    m_used_list.push_back(pConn);        //
    return pConn;
}

pDBPool->RelDBConn(pDBConn); // 一定要归还


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

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