Entity Framework操作PostgreSQL时，如何在查询阶段锁定资源？

核心问题 #

你当前用Serializable隔离级别没达到预期，因为PostgreSQL的Serializable是基于快照的，不会在查询阶段加行锁，只会在事务提交时检查冲突；而且两次数据库查询（Count+分页）的间隙会让并发请求拿到相同数据。另外Chaos级别是SQL Server专属，PostgreSQL不支持，报错属于正常情况。

直接解决方案：在EF查询中添加FOR UPDATE #

要在查询阶段就锁定资源，直接用Npgsql EF Core提供的ForUpdate()扩展方法，这是官方支持的最优雅方式。

步骤1：确认依赖 #

确保你安装了Npgsql.EntityFrameworkCore.PostgreSQL包（版本3.0及以上），这个扩展是官方自带的。

步骤2：修改查询逻辑 #

在查询链中加入.ForUpdate()，生成SELECT...FOR UPDATE语句，查询时直接锁定符合条件的行：

var query = _dbContext.ValidationRequests
        .Where(vr => vr.State == Statuses.New)
        .OrderBy(vr => vr.Id)
        .ForUpdate(); // 关键：添加行级锁

如果是任务分发场景，不想让请求阻塞等待已锁定的行，可以用.ForUpdateSkipLocked()直接跳过锁定数据：

var query = _dbContext.ValidationRequests
        .Where(vr => vr.State == Statuses.New)
        .OrderBy(vr => vr.Id)
        .ForUpdateSkipLocked();

步骤3：调整事务隔离级别 #

加了ForUpdate()后，用ReadCommitted隔离级别就足够了，Serializable反而会增加不必要的开销：

await using var transaction = await _dbContext.Database.BeginTransactionAsync(
    System.Data.IsolationLevel.ReadCommitted,
    cancellationToken);

修复分页逻辑的间隙问题 #

原来的分页方法先Count再Skip/Take，两次查询之间有空隙，可能导致并发请求钻空子。可以合并成一次查询获取总数和分页数据（适合数据量不大的场景）：

public static async Task<PagedList<T>> GetPagedListAsync(
        IQueryable<T> query,
        int page,
        int pageSize,
        CancellationToken cancellationToken = default)
{
    var pagedQuery = query.Select(x => new { Item = x, TotalCount = query.Count() })
                          .Skip((page - 1) * pageSize)
                          .Take(pageSize);

    var results = await pagedQuery.ToListAsync(cancellationToken);
    if (!results.Any())
    {
        return new PagedList<T>(page, pageSize, new List<T>(), 0);
    }

    int totalCount = results.First().TotalCount;
    var items = results.Select(r => r.Item).ToList();
    return new PagedList<T>(page, pageSize, items, totalCount);
}

如果数据量很大，推荐用原生SQL一次完成分页和计数，避免两次查询的性能问题：

var sql = @"
SELECT *, COUNT(*) OVER() AS TotalCount 
FROM ""ValidationRequests"" 
WHERE ""State"" = {0} 
ORDER BY ""Id"" 
FOR UPDATE 
OFFSET {1} LIMIT {2}";

var parameters = new object[] { Statuses.New, (page-1)*pageSize, pageSize };
var results = await _dbContext.ValidationRequests
    .FromSqlRaw(sql, parameters)
    .ToListAsync(cancellationToken);

int totalCount = results.Any() ? results.First().TotalCount : 0;
var items = results.Take(pageSize).ToList();
var response = new PagedList<Model>(page, pageSize, items, totalCount);

修改后的完整代码 #

await using var transaction = await _dbContext.Database.BeginTransactionAsync(
    System.Data.IsolationLevel.ReadCommitted,
    cancellationToken);

try
{
    var query = _dbContext.ValidationRequests
            .Where(vr => vr.State == Statuses.New)
            .OrderBy(vr => vr.Id)
            .ForUpdate();

    var response = await PagedList<Model>.GetPagedListAsync(
        query,
        page,
        pageSize,
        cancellationToken
    );

    await UpdateRangeAsync(response.Items, cancellationToken);

    await transaction.CommitAsync(cancellationToken);

    return response;
}
catch (Exception)
{
    await transaction.RollbackAsync(cancellationToken);
    throw;
}

补充说明 #

• PostgreSQL的Serializable隔离级别不会在查询阶段加锁，而是通过提交时的冲突检测来保证序列化，无法满足你“查询阶段锁资源”的需求。
• Chaos隔离级别是SQL Server特有的，PostgreSQL不支持，无需纠结。

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