22. 数据库访问优化：连接池、批量操作、预处理语句

数据库访问，往往是整个服务最慢的一环。我见过太多项目，业务逻辑写得飞快，结果一查数据库，慢得像蜗牛爬。说白了，数据库优化是性能优化的「大头」，绕不过去。

今天咱们聊三个最实用的优化手段：连接池、批量操作、预处理语句。这三板斧用好了，数据库访问性能能提升一个数量级。

22.1 连接池：别再频繁创建连接了

每次数据库操作都新建连接、用完再关闭？这简直是性能杀手。我早期做的一个项目就是这样，每次请求都 new 一个连接，结果数据库服务器 CPU 飙升，连接数爆满。

为什么会这样？因为建立数据库连接是个重量级操作——TCP 三次握手、认证、会话初始化，一套下来少说几十毫秒。如果每次请求都来一遍，光连接开销就占了大部分时间。

连接池的核心思想：预先创建一批连接，放在池子里。需要时从池里取，用完放回去。这样避免了频繁创建和销毁的开销。

下面是一个简单的连接池实现思路：

// 连接池核心接口
class ConnectionPool {
public:
    // 初始化池子，创建 minSize 个连接
    void init(int minSize, int maxSize, int timeoutMs);
    
    // 从池中获取连接（带超时）
    std::shared_ptr<Connection> getConnection();
    
    // 归还连接到池中
    void releaseConnection(std::shared_ptr<Connection> conn);
    
private:
    std::queue<std::shared_ptr<Connection>> pool_;
    std::mutex mutex_;
    std::condition_variable cv_;
    int maxSize_;
};

实际项目中，我一般用现成的连接池库，比如 MySQL Connector/C++ 自带的连接池，或者自己封装一个简单的。嗯，这里要注意：连接池一定要做心跳检测，防止连接被数据库端断开后还在池子里「装睡」。

22.2 批量操作：一次搞定，别分多次

你有没有见过这样的代码：循环 1000 次，每次 insert 一条记录？每次 insert 都是一次网络往返，1000 次就是 1000 次网络开销。你想想看，这得多慢。

批量操作就是把多条 SQL 打包成一次发送。数据库一次解析、一次执行，效率高得多。

举个例子，批量插入：

// 错误做法：逐条插入
for (const auto& record : records) {
    db.execute("INSERT INTO users(name, age) VALUES('" + record.name + "', " + record.age + ")");
}

// 正确做法：批量插入
std::string sql = "INSERT INTO users(name, age) VALUES ";
for (size_t i = 0; i < records.size(); ++i) {
    if (i > 0) sql += ", ";
    sql += "('" + records[i].name + "', " + std::to_string(records[i].age) + ")";
}
db.execute(sql);

批量操作的好处不止是减少网络往返。数据库内部也能优化——比如批量插入时，MySQL 可以一次构建 B+ 树索引，比逐条插入快得多。

不过批量操作也不是越大越好。一次插入几百万条，SQL 语句太长，内存占用也大。我一般控制在 500-1000 条一批，既高效又不会撑爆内存。

22.3 预处理语句：安全又高效

预处理语句，说白了就是先把 SQL 模板发给数据库，数据库解析好、生成执行计划，然后每次只传参数。这样避免了重复解析的开销。

而且预处理语句还能防 SQL 注入——参数和 SQL 模板是分开的，参数不会被当作 SQL 执行。

// 预处理语句示例（MySQL Connector/C++）
std::string sql = "INSERT INTO users(name, age) VALUES(?, ?)";
std::unique_ptr<sql::PreparedStatement> pstmt(conn->prepareStatement(sql));

for (const auto& record : records) {
    pstmt->setString(1, record.name);
    pstmt->setInt(2, record.age);
    pstmt->executeUpdate();  // 每次只传参数，不重新解析
}

为什么预处理语句快？因为数据库解析 SQL 是个 CPU 密集型操作。如果同一个 SQL 执行 1000 次，用预处理语句只解析 1 次，而普通 SQL 要解析 1000 次。你想想看，这差距有多大。

22.4 三者结合：实战中的最佳实践

在实际项目中，我通常把连接池、批量操作、预处理语句结合起来用。下面是一个典型的场景：

// 综合示例：批量插入用户数据
class UserService {
public:
    void batchInsertUsers(const std::vector<User>& users) {
        // 1. 从连接池获取连接
        auto conn = pool_->getConnection();
        
        // 2. 准备预处理语句
        std::string sql = "INSERT INTO users(name, age, email) VALUES(?, ?, ?)";
        auto pstmt = conn->prepareStatement(sql);
        
        // 3. 批量执行
        const int BATCH_SIZE = 500;
        for (size_t i = 0; i < users.size(); ++i) {
            pstmt->setString(1, users[i].name);
            pstmt->setInt(2, users[i].age);
            pstmt->setString(3, users[i].email);
            pstmt->addBatch();  // 添加到批处理
            
            if ((i + 1) % BATCH_SIZE == 0) {
                pstmt->executeBatch();  // 批量发送
            }
        }
        // 处理剩余数据
        if (users.size() % BATCH_SIZE != 0) {
            pstmt->executeBatch();
        }
        
        // 4. 归还连接到池子
        pool_->releaseConnection(conn);
    }
    
private:
    std::shared_ptr<ConnectionPool> pool_;
};

这个例子把三个优化都用上了：连接池避免频繁创建连接，预处理语句避免重复解析，批量操作减少网络往返。三者叠加，性能提升非常明显。

22.5 知识体系总览

下面这张图总结了数据库访问优化的核心思路：

从图中可以看出，这三个优化点各自解决不同的问题，但组合起来效果最好。连接池解决连接开销，批量操作解决网络开销，预处理语句解决解析开销。三者互补，缺一不可。

---

公众号：蓝海资料掘金营，微信 deep3321