五、数据库连接池调优

5.1 HikariCP配置详解（当前性能最强）

spring:
  datasource:
    hikari:
      # 核心配置
      minimum-idle: 10               # 最小空闲连接数
      maximum-pool-size: 20          # 最大连接池大小（公式：((core_count * 2) + effective_spindle_count)）
      connection-timeout: 30000      # 连接超时（ms）
      idle-timeout: 600000           # 空闲超时（10分钟）
      max-lifetime: 1800000          # 连接最大生命周期（30分钟）

      # 性能优化配置
      connection-test-query: SELECT 1
      validation-timeout: 5000
      leak-detection-threshold: 60000  # 连接泄漏检测（60秒）

      # MySQL特定配置
      data-source-properties:
        cachePrepStmts: true
        prepStmtCacheSize: 250
        prepStmtCacheSqlLimit: 2048
        useServerPrepStmts: true
        useLocalSessionState: true
        rewriteBatchedStatements: true
        cacheResultSetMetadata: true
        cacheServerConfiguration: true
        elideSetAutoCommits: true
        maintainTimeStats: false

5.2 连接池大小公式
Tomcat JDBC / HikariCP 通用公式：

实际建议：

单机部署：最大连接数 = CPU核心数 × 2

微服务场景：单个服务连接数不宜超过50

// 动态调整连接池（根据负载）
@Component
public class DynamicDataSourceConfig {

    @EventListener
    public void handleSlowQuery(SlowQueryEvent event) {
        HikariPoolMXBean poolMXBean = getPoolMXBean();
        int activeConnections = poolMXBean.getActiveConnections();
        int maxConnections = poolMXBean.getMaximumPoolSize();

        if (activeConnections > maxConnections * 0.8) {
            // 连接使用率超过80%，扩容
            poolMXBean.setMaximumPoolSize(maxConnections + 5);
            log.warn("连接池扩容至: {}", maxConnections + 5);
        }
    }
}

5.3 连接泄漏检测

// 配置泄漏检测（生产环境建议开启）
@Configuration
public class DataSourceConfig {

    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setLeakDetectionThreshold(30000);  // 30秒未归还即告警
        config.setConnectionTimeout(30000);
        return new HikariDataSource(config);
    }
}

// 监控连接状态
@Scheduled(fixedDelay = 60000)
public void monitorConnections() {
    HikariPoolMXBean poolMXBean = getPoolMXBean();
    logger.info("连接池状态: 活跃={}, 空闲={}, 总数={}, 等待线程={}",
        poolMXBean.getActiveConnections(),
        poolMXBean.getIdleConnections(),
        poolMXBean.getTotalConnections(),
        poolMXBean.getThreadsAwaitingConnection());
}

六、事务隔离级别与锁机制

6.1 四种隔离级别对比

6.2 MVCC原理（多版本并发控制）

-- InnoDB每行数据隐藏列：
-- DB_TRX_ID: 最后修改的事务ID
-- DB_ROLL_PTR: 回滚指针（指向undo log）
-- DB_ROW_ID: 行ID（聚簇索引无此列）

-- READ COMMITTED下：每次查询生成新的ReadView
-- REPEATABLE READ下：事务内第一次查询生成ReadView，后续复用

-- 查看当前事务ID
SELECT TRX_ID FROM information_schema.innodb_trx WHERE TRX_MYSQL_THREAD_ID = CONNECTION_ID();

6.3 锁的类型与使用场景

-- 行锁（InnoDB默认）
-- 注意：只有通过索引查询才会使用行锁，否则升级为表锁

-- 共享锁（S锁）：允许其他事务读，不允许写
SELECT * FROM orders WHERE id = 1 LOCK IN SHARE MODE;
-- 排他锁（X锁）：不允许其他事务读和写
SELECT * FROM orders WHERE id = 1 FOR UPDATE;

-- 间隙锁（Gap Lock）：锁定范围，防止幻读（仅在REPEATABLE READ级别）
-- 假设orders表id有1,2,5,10
SELECT * FROM orders WHERE id BETWEEN 3 AND 7 FOR UPDATE;
-- 锁定范围：(2,5)、(5,10)

-- 临键锁（Next-Key Lock）= 行锁 + 间隙锁

-- 死锁示例与排查
-- 事务A：
BEGIN;
UPDATE orders SET status = 1 WHERE id = 1;
UPDATE orders SET status = 2 WHERE id = 2;
COMMIT;

-- 事务B：
BEGIN;
UPDATE orders SET status = 3 WHERE id = 2;
UPDATE orders SET status = 4 WHERE id = 1;
COMMIT;
-- 可能死锁

-- 查看死锁信息
SHOW ENGINE INNODB STATUS\G
-- 死锁日志位置：/var/log/mysql/error.log

-- 避免死锁策略：
-- 1. 固定访问顺序（按主键排序）
-- 2. 缩短事务时间
-- 3. 使用低隔离级别
-- 4. 添加合适的索引

6.4 事务最佳实践

@Service
@Transactional(rollbackFor = Exception.class)
public class OrderService {

    // 正确做法：事务边界清晰，粒度适中
    public void createOrder(OrderDTO dto) {
        // 1. 校验（非数据库操作，放在事务外）
        validateOrder(dto);

        // 2. 核心业务（事务内）
        Order order = new Order();
        order.setUserId(dto.getUserId());
        order.setAmount(dto.getAmount());
        orderMapper.insert(order);

        // 3. 扣库存（分布式事务场景考虑最终一致性）
        inventoryService.decreaseStock(dto.getProductId(), dto.getQuantity());

        // 4. 发送消息（事务内无法保证消息可靠，使用事务消息）
        eventPublisher.publish(new OrderCreatedEvent(order.getId()));
    }

    // 错误做法1：事务过大（包含RPC、文件操作）
    @Transactional
    public void badMethod() {
        orderMapper.insert(order);
        restTemplate.postForObject("http://payment/pay", order, Void.class);  // RPC
        fileService.writeToFile(order);  // 文件IO
        // 问题：事务期间持有数据库连接，RPC/IO阻塞会导致连接长时间占用
    }

    // 错误做法2：捕获异常不抛出
    @Transactional
    public void badMethod2() {
        try {
            orderMapper.insert(order);
            int i = 1 / 0;  // 抛出异常
        } catch (Exception e) {
            // 捕获后不抛出，事务不会回滚！
            log.error("error", e);
        }
    }

    // 错误做法3：事务传播级别使用不当
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void createLog(Log log) {
        // 独立事务，不受外层事务影响
        logMapper.insert(log);
    }
}

6.5 事务传播级别详解

// NESTED的使用场景：部分回滚
@Transactional
public void parentMethod() {
    orderMapper.insert(order1);
    try {
        childMethod();  // 失败只回滚childMethod内的操作
    } catch (Exception e) {
        // childMethod已回滚，parentMethod继续
    }
    orderMapper.insert(order2);
}

@Transactional(propagation = Propagation.NESTED)
public void childMethod() {
    // 嵌套事务，内部失败只回滚到保存点
}

来源：
http://hllft.cn/