.NET 6与PostgreSQL环境下InsertData接口并发调用处理咨询

你的问题核心是竞态条件：并发请求同时读取ColIndex的最大值，导致后续的递增逻辑生成重复值。下面给几个兼顾性能和可靠性的解决思路，按推荐优先级排序：

1. 数据库序列+触发器（最优方案） #

直接把ColIndex的递增逻辑交给PostgreSQL处理，利用数据库原生的序列（Sequence）保证原子性，性能几乎无损耗，还不用改应用层核心逻辑。

操作步骤： #

• 创建一个专用于ColIndex的序列：

CREATE SEQUENCE colindex_seq START WITH 1 INCREMENT BY 1;

• 创建触发器函数，插入数据前自动给ColIndex赋值序列的下一个值：

CREATE OR REPLACE FUNCTION set_colindex()
RETURNS TRIGGER AS $$
BEGIN
    -- 若业务允许手动指定ColIndex，可加判断：IF NEW.ColIndex IS NULL THEN ...
    NEW.ColIndex := nextval('colindex_seq');
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

• 把触发器绑定到目标表（假设表名为target_table）：

CREATE TRIGGER trigger_set_colindex
BEFORE INSERT ON target_table
FOR EACH ROW EXECUTE FUNCTION set_colindex();

优势： #

• 完全由数据库控制，彻底避免应用层的竞态问题
• 序列是PostgreSQL原生高效原子操作，性能影响可忽略
• 应用层可删掉原来的「获取最大值+递增」逻辑，直接插入数据即可

2. 原子化插入SQL语句（无需改表结构） #

如果不想创建序列和触发器，可以把「获取最大值+分配索引+插入」合并成一个原子SQL操作，让PostgreSQL保证这个过程的排他性。

示例SQL（插入多条数据场景）： #

INSERT INTO target_table (ColIndex, column1, column2)
SELECT
    -- 计算每条数据的ColIndex：当前最大值 + 行号
    (SELECT COALESCE(MAX(ColIndex), 0) FROM target_table) + row_number() OVER (),
    t.column1,
    t.column2
FROM unnest(@data_list) t(column1, column2);

在.NET中可通过Npgsql传递数组参数，把要插入的数据打包成数组传给数据库。

优势： #

• 无需修改表结构或创建额外对象
• 单个SQL语句保证原子性，避免竞态
• 性能优于应用层锁，所有逻辑在数据库端完成

3. 应用层分布式锁（适合必须在应用层控制的场景） #

如果业务逻辑要求必须在应用层计算ColIndex，那需要用分布式锁保证同一时间只有一个请求进入临界区。单实例部署可用内存锁；多实例则必须用数据库或Redis做分布式锁。

单实例内存锁示例（.NET 6）： #

// 全局声明SemaphoreSlim，初始计数1，最多允许1个线程进入
private static readonly SemaphoreSlim _colIndexLock = new(1, 1);

public async Task InsertDataAsync(List<DataModel> dataList)
{
    await _colIndexLock.WaitAsync();
    try
    {
        using var transaction = await _dbContext.Database.BeginTransactionAsync();
        try
        {
            var maxIndex = await _dbContext.TargetTable.MaxAsync(t => t.ColIndex) ?? 0;
            foreach (var data in dataList)
            {
                maxIndex++;
                data.ColIndex = maxIndex;
                _dbContext.TargetTable.Add(data);
            }
            await _dbContext.SaveChangesAsync();
            await transaction.CommitAsync();
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
    finally
    {
        _colIndexLock.Release();
    }
}

多实例分布式锁示例（用PostgreSQL行锁）： #

先建一个锁表app_locks：

CREATE TABLE app_locks (
    lock_key VARCHAR(50) PRIMARY KEY,
    created_at TIMESTAMP DEFAULT NOW()
);
-- 插入初始锁记录
INSERT INTO app_locks (lock_key) VALUES ('colindex_lock') ON CONFLICT DO NOTHING;

然后在.NET代码里用事务加行锁：

public async Task InsertDataAsync(List<DataModel> dataList)
{
    using var transaction = await _dbContext.Database.BeginTransactionAsync();
    try
    {
        -- 先获取锁行，FOR UPDATE会锁住这条记录，直到事务结束
        await _dbContext.AppLocks.FirstOrDefaultAsync(l => l.LockKey == "colindex_lock", transaction);
        
        var maxIndex = await _dbContext.TargetTable.MaxAsync(t => t.ColIndex) ?? 0;
        foreach (var data in dataList)
        {
            maxIndex++;
            data.ColIndex = maxIndex;
            _dbContext.TargetTable.Add(data);
        }
        await _dbContext.SaveChangesAsync();
        await transaction.CommitAsync();
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
}

注意： #

• 内存锁仅适用于单实例部署，多实例环境会失效
• 分布式锁会有一定等待开销，但远优于不控制导致的重复问题
• 需设置合理的锁超时时间，避免死锁

内容的提问来源于stack exchange，提问作者Ashok Ananthan