启用 ASP.Net Core Session 锁定？

Question

根据 ASP.Net Core docs ， session state 的行为已经改变，因为它现在是非锁定的：

Session state 是非锁定的。 如果两个请求同时尝试修改 session 的内容，则最后一个请求将覆盖第一个请求。 Session 实现为连贯的 session，这意味着所有内容都存储在一起。 当两个请求试图修改不同的 session 值时，最后一个请求可能会覆盖第一个请求所做的 session 更改。

我的理解是，这与 .Net Framework 中 session 的行为不同，其中用户的 session 每个请求都被锁定，因此无论何时读取/写入它，都不会覆盖另一个请求的数据或读取过时的数据, 对于该用户。

我的问题：

1. 有没有办法重新启用用户的 session in.Net Core 的每个请求锁定？

2. 如果没有，是否有可靠的方法使用 session 来防止给定用户重复提交数据？ 举一个具体的例子，我们有一个支付流程，涉及用户从外部托管的 ThreeDSecure (3DS) iFrame（支付卡安全流程）返回。 我们注意到有时（不知何故）用户在 iFrame 中多次提交表单，这是我们无法控制的。 因此，这会触发对我们应用程序的多个回调。 在我们之前的 .Net Framework 应用程序中，我们使用 session 来指示付款是否正在进行中。 如果在 session 中设置了此标志并且您再次点击 3DS 回调，应用程序将阻止您继续。 然而，现在看来，因为 session 没有被锁定，当这些几乎同时发生的重复回调发生时，线程“A”设置“付款进行中 = true”但线程“B”没有及时看到，它是快照session 的 'payment in progress = false' 并且回调逻辑被处理了两次。

既然 session 的工作方式发生了变化，那么处理访问同一 session 的同时请求有哪些好的方法？

Answer 1

您面临的问题称为竞争条件（ stackoverflow ， wiki ）。 要突破，您希望获得对 session state 的独家访问权，您可以通过多种方式实现这一目标，它们高度依赖于您的架构。

进程内同步

如果您有一台机器和一个进程处理所有请求（例如，您使用自托管服务器 Kestrel），则可以使用lock 。 只要正确地做，而不是@TMG 建议的方式。

这是一个实现参考：

1. 使用单个全局 object 锁定所有线程：

  private static object s_locker = new object();

  public bool Process(string transaction) {
      lock (s_locker) {
        if(!HttpContext.Session.TryGetValue("TransactionId", out _)) {
           ... handle transaction
        }
      }
  }

优点：一个简单的解决方案缺点：所有用户的所有请求都将等待这个锁

2. 使用每会话锁定 object。 想法是相似的，但是您只需使用字典而不是单个 object：

    internal class LockTracker : IDisposable
    {
        private static Dictionary<string, LockTracker> _locks = new Dictionary<string, LockTracker>();
        private int _activeUses = 0;
        private readonly string _id;

        private LockTracker(string id) => _id = id;

        public static LockTracker Get(string id)
        {
            lock(_locks)
            {
                if(!_locks.ContainsKey(id))
                    _locks.Add(id, new LockTracker(id));
                var res = _locks[id];
                res._activeUses += 1;
                return res;
            }
        }

        void IDisposable.Dispose()
        {
            lock(_locks)
            {
                _activeUses--;
                if(_activeUses == 0)
                    _locks.Remove(_id);
            }
        }
    }


public bool Process(string transaction)
{
    var session = HttpContext.Session;
    var locker = LockTracker.Get(session.Id);
    using(locker) // remove object after execution if no other sessions use it
    lock (locker) // synchronize threads on session specific object
    {
        // check if current session has already transaction in progress
        var transactionInProgress = session.TryGetValue("TransactionId", out _);
        if (!transactionInProgress)
        {
            // if there is no transaction, set and handle it
            HttpContext.Session.Set("TransactionId", System.Text.Encoding.UTF8.GetBytes(transaction));
            HttpContext.Session.Set("StartTransaction", BitConverter.GetBytes(DateTimeOffset.UtcNow.ToUnixTimeSeconds()));
            // handle transaction here
        }
        // return whatever you need, here is just a boolean.
        return transactionInProgress;
    }
}

优点：管理 session 级别的并发 缺点：更复杂的解决方案

请记住，基于锁的选项仅在处理所有用户请求的网络服务器上的同一进程时才有效 - 锁是进程内同步机制，具体取决于您用作会话的持久层（如 NCache 或 Redis）。 不过，此选项可能是性能最高的。

跨进程同步

如果机器上有多个进程（例如你有 IIS 并且 apppool 被配置为运行多个工作进程），那么你需要使用内核级同步原语，比如Mutex 。

跨机同步

如果您的 webfarm 前面有一个负载均衡器 (LB)，以便 N 台机器中的任何一台都可以处理用户的请求，那么获得独占访问权限就不是那么简单了。

这里的一个选项是通过启用 LB 中的“ sticky session ”选项来简化问题，以便将来自同一用户（会话）的所有请求路由到同一台机器。 在这种情况下，您可以使用任何跨进程或进程内同步选项（取决于您在那里运行的内容）。

另一种选择是将同步外部化，例如，将其移动到事务数据库，类似于@HoomanBahreini 的建议。 请注意，您在处理故障情况时需要非常谨慎：您可以将 session 标记为正在进行中，然后处理它的网络服务器崩溃并将其锁定在数据库中。

重要的

在所有这些选项中，您必须确保在读取 state之前获得锁定并持有它直到您更新 state。

请说明最接近您的情况的选项，我可以提供更多技术细节。

Answer 2

Session 旨在在多个请求中存储临时用户数据，一个很好的例子是登录状态......没有 session 你将不得不登录到stackoverflow.com因为每次打开一个新问题网站都会记住你......您将您的 session state 发送到 cookie 中。 根据微软：

session 数据由缓存支持并被视为临时数据。 该站点应继续 function 没有 session 数据。 关键应用程序数据应存储在用户数据库中并缓存在 session 中，仅作为性能优化。

实施锁定机制来解决互斥锁问题非常简单，但是 session 本身不是可靠的存储，您可能随时丢失其内容。

如何识别重复付款？

问题是您收到多个付款请求，并且您想丢弃重复的付款……您对重复付款的定义是什么？

您当前的解决方案在第一次付款正在进行时放弃第二次付款...假设您的付款需要 2 秒才能完成...如果您在 3 秒后收到重复付款会发生什么？

每个可靠的支付系统在他们的请求中都包含一个唯一的PaymentId ......您需要做的是将此PaymentId标记为在您的数据库中处理。 这样，无论重复请求何时到达，您都不会两次处理相同的付款。

您可以在PaymentId上使用Unique Constraint来防止重复付款：

public bool ProcessPayment(Payment payment) {
    bool res = InsertIntoDb(payment);
    if (res == false) {
        return false; // <-- insert has failed because PaymentId is not unique
    }        
    
    Process(payment);
    return true;
}

使用lock的相同示例：

public class SafePayment {
    private static readonly Object lockObject = new Object();

    public bool ProcessPayment(Payment payment) {
        lock (lockObject) {
            var duplicatePayment = ReadFromDb(payment.Id);
            if (duplicatePayment != null) {
                return false; // <-- duplicate 
            }
            
            Process(payment);
            WriteToDb(payment);
            return true;
        }
    }
}