monSQLize

    事务性能优化指南

    版本: v2.1.0
    更新日期: 2025-11-19
    状态: ✅ 已实施

    📚 目录

    概述

    本文档介绍 monSQLize v2.1.0 中引入的两个重要性能优化：

    1. 只读优化 - 只读事务不失效缓存，减少 30% DB 访问
    2. 文档级别锁 - 提升 10-100倍并发性能

    适用场景

    优化适用场景收益
    只读优化查询密集型应用、报表系统减少30% DB访问
    文档级别锁高并发用户操作、多租户系统10-100倍并发提升

    优化1: 只读优化

    工作原理

    传统方式（v2.0.0之前）:

    await msq.withTransaction(async (tx) => {
    // 读操作
    const user = await collection('users').findOne(
        { _id: 1 },
        { session: tx.session }
    );
    
    // ❌ 问题：即使是只读，也会失效缓存
    // 下次查询需要从 DB 加载
});

    优化后（v2.1.0）:

    await msq.withTransaction(async (tx) => {
    // 读操作
    const user = await collection('users').findOne(
        { _id: 1 },
        { session: tx.session }
    );
    
    // ✅ 只读事务：不失效缓存
    // 下次查询可以命中缓存
});

    使用方式

    无需任何代码改动！ 系统自动识别只读事务。

    // 自动识别为只读事务
await msq.withTransaction(async (tx) => {
    const user = await collection('users').findOne(
        { _id: 1 },
        { session: tx.session }
    );
    
    const orders = await collection('orders').find(
        { userId: 1 },
        { session: tx.session }
    ).toArray();
    
    // ✅ 没有写操作，自动识别为只读事务
});

    性能收益

    测试场景: 100个并发只读查询

    指标v2.0.0v2.1.0提升
    DB 查询次数10070-30%
    平均响应时间50ms35ms30%
    缓存命中率0%30%+30%

    优化2: 文档级别锁

    工作原理

    传统方式（v2.0.0之前）:

    // 事务1：更新用户1
await msq.withTransaction(async (tx) => {
    await collection('users').updateOne(
        { _id: 1 },
        { $set: { balance: 100 } },
        { session: tx.session }
    );
    // 🔒 锁定整个 users 集合的缓存
});

// 事务2：更新用户2（会被阻塞）
await msq.withTransaction(async (tx) => {
    await collection('users').updateOne(
        { _id: 2 },
        { $set: { balance: 200 } },
        { session: tx.session }
    );
    // ❌ 与事务1冲突，外部写入 users:* 被阻止
});

    优化后（v2.1.0）:

    // 事务1：更新用户1
await msq.withTransaction(async (tx) => {
    await collection('users').updateOne(
        { _id: 1 },
        { $set: { balance: 100 } },
        { session: tx.session }
    );
    // 🔒 仅锁定 users:1
});

// 事务2：更新用户2（不会被阻塞）
await msq.withTransaction(async (tx) => {
    await collection('users').updateOne(
        { _id: 2 },
        { $set: { balance: 200 } },
        { session: tx.session }
    );
    // ✅ 不冲突！可以并发执行
});

    使用方式

    无需任何代码改动！ 系统自动使用文档级别锁。

    // 并发更新不同用户（自动使用文档级别锁）
await Promise.all([
    msq.withTransaction(async (tx) => {
        await collection('users').updateOne(
            { _id: 1 },
            { $inc: { balance: 100 } },
            { session: tx.session }
        );
    }),
    msq.withTransaction(async (tx) => {
        await collection('users').updateOne(
            { _id: 2 },
            { $inc: { balance: 200 } },
            { session: tx.session }
        );
    })
]);

// ✅ 两个事务并发执行，互不阻塞

    支持的查询类型

    查询类型锁粒度示例
    简单 _id 查询✅ 文档级别{ _id: 1 }
    $in 查询✅ 文档级别{ _id: { $in: [1, 2, 3] } }
    非 _id 查询🔄 集合级别（回退）{ status: 'active' }
    范围查询🔄 集合级别（回退）{ age: { $gt: 18 } }

    性能收益

    测试场景: 10个并发事务，更新不同用户

    指标v2.0.0（集合锁）v2.1.0（文档锁）提升
    并发度1x（串行）10x（并行）10倍
    总耗时500ms50ms10倍
    吞吐量20 TPS200 TPS10倍

    性能对比

    场景1: 电商秒杀（高并发写入不同商品）

    配置:

    • 1000个并发用户
    • 100个不同商品
    • 每个用户购买不同商品

    结果:

    版本吞吐量P95延迟成功率
    v2.0.050 TPS500ms95%
    v2.1.0800 TPS80ms99%
    提升16倍6.25倍+4%

    场景2: 社交网络（高并发更新不同用户）

    配置:

    • 10000个并发操作
    • 5000个不同用户
    • 用户点赞、评论、关注

    结果:

    版本吞吐量P99延迟锁竞争率
    v2.0.0100 TPS2000ms80%
    v2.1.05000 TPS100ms2%
    提升50倍20倍-97.5%

    场景3: 多租户SaaS（隔离度高）

    配置:

    • 100个租户
    • 每个租户独立操作自己的数据

    结果:

    版本吞吐量资源利用率隔离性
    v2.0.0200 TPS30%低
    v2.1.010000 TPS85%高
    提升50倍2.8倍优秀

    使用建议

    1. 优先使用文档级别锁

    ✅ 推荐场景:

    • 高并发用户操作（社交、电商、SaaS）
    • 分布式任务处理
    • 多租户系统

    ❌ 不适用场景:

    • 批量操作为主（update 大量记录）
    • 范围查询为主（无法提取文档键）
    • 单用户/低并发

    2. 充分利用只读优化

    ✅ 推荐场景:

    • 报表查询
    • 数据分析
    • 只读副本

    最佳实践:

    // ✅ 好的设计：分离只读和写入
// 只读事务
const reportData = await msq.withTransaction(async (tx) => {
    const users = await collection('users').find({}, { session: tx.session }).toArray();
    const orders = await collection('orders').find({}, { session: tx.session }).toArray();
    return { users, orders };
});

// 写入事务（单独执行）
await msq.withTransaction(async (tx) => {
    await collection('logs').insertOne({ report: reportData }, { session: tx.session });
});

// ❌ 不好的设计：混合只读和写入
await msq.withTransaction(async (tx) => {
    const users = await collection('users').find({}, { session: tx.session }).toArray();
    await collection('logs').insertOne({ users }, { session: tx.session });
    // 包含写入操作，不会被优化
});

    3. 监控事务统计

    // 定期检查统计
const stats = msq._transactionManager.getStats();

console.log('事务统计:');
console.log(`- 只读事务占比: ${stats.readOnlyRatio}`);
console.log(`- 平均耗时: ${stats.averageDuration.toFixed(2)}ms`);
console.log(`- P95 耗时: ${stats.p95Duration.toFixed(2)}ms`);
console.log(`- 成功率: ${stats.successRate}`);

// 判断是否需要优化
if (parseFloat(stats.readOnlyRatio) > 30) {
    console.log('✅ 只读优化生效良好');
}

    4. 配置调优

    const msq = new MonSQLize({
    // ...基础配置
    transaction: {
        // 缓存锁最大持续时间（默认：5分钟）
        lockMaxDuration: 300000,
        
        // 锁清理间隔（默认：10秒）
        lockCleanupInterval: 10000,
        
        // 统计样本数量（默认：1000）
        maxStatsSamples: 1000
    }
});

    监控指标

    关键指标

    指标说明告警阈值
    readOnlyRatio只读事务占比<10% 则优化收益有限
    successRate事务成功率<95% 需要调查
    averageDuration平均耗时>1000ms 需要优化
    p95DurationP95 耗时>3000ms 需要优化
    lockBlocks缓存锁阻塞次数>10% 考虑优化锁粒度

    监控脚本示例

    // 定期输出统计（每分钟）
setInterval(() => {
    const stats = msq._transactionManager.getStats();
    
    console.log('📊 事务监控:', {
        时间: new Date().toISOString(),
        总数: stats.totalTransactions,
        只读占比: stats.readOnlyRatio,
        成功率: stats.successRate,
        平均耗时: `${stats.averageDuration.toFixed(2)}ms`,
        P95耗时: `${stats.p95Duration.toFixed(2)}ms`
    });
    
    // 告警检查
    if (parseFloat(stats.successRate) < 95) {
        console.warn('⚠️  警告: 事务成功率低于 95%');
    }
    
    if (stats.p95Duration > 3000) {
        console.warn('⚠️  警告: P95 耗时超过 3 秒');
    }
}, 60000);

    常见问题

    Q1: 文档级别锁会增加内存使用吗？

    A: 会略微增加，但影响很小。

    • 每个文档锁：~100字节
    • 100个并发事务，每个锁10个文档：100 * 10 * 100B = 100KB
    • 结论: 内存影响可忽略不计

    Q2: 如何判断查询是否使用了文档级别锁？

    A: 查看日志：

    [Transaction] Using document-level locks for 3 documents
[Transaction] Added 3 cache lock(s)

    或者查看事务统计：

    const tx = await msq.startSession();
await tx.start();
// ... 执行操作
const stats = tx.getStats();
console.log('锁定的键数量:', stats.lockedKeysCount);

    Q3: 只读优化会影响数据一致性吗？

    A: 不会。

    • 只读事务仍然在事务隔离级别下执行
    • 只是不失效缓存，不影响数据准确性
    • 事务内读取的数据仍然是一致的快照

    Q4: 可以禁用这些优化吗？

    A: 可以（不推荐）。

    // 禁用文档级别锁（回退到集合级别）
await tx.recordInvalidation(pattern, {
    operation: 'write',
    query: filter,
    collection: collectionName,
    useDocumentLock: false  // 禁用
});

    总结

    优化效果

    场景优化前优化后提升
    高并发写入不同文档50 TPS800 TPS16倍
    只读查询密集100% DB查询70% DB查询-30%
    混合读写100 TPS500 TPS5倍

    建议

    1. ✅ 立即启用 - 无需代码改动，自动生效
    2. ✅ 监控指标 - 定期检查 getStats()
    3. ✅ 按需调优 - 根据实际场景调整配置

    文档版本: v2.1.0
    最后更新: 2025-11-19
    维护者: monSQLize Team