ASP.NET锁定线程的方法

Question

我正在使用 C# 开发 ASP.NET 表单 Web 应用程序。我有一种为客户创建新订单的方法。它看起来与此类似；

    private string CreateOrder(string userName) {
        // Fetch current order
        Order order = FetchOrder(userName);
        if (order.OrderId == 0) {
            // Has no order yet, create a new one
            order.OrderNumber = Utility.GenerateOrderNumber();
            order.Save();
        }
        return order;
    }

这里的问题是，两个请求（线程）中的 1 个客户可能会导致该方法被调用两次，而另一个线程也在该方法内。这可能会导致创建两个订单。

如何正确锁定此方法，以便每个客户一次只能由一个线程执行？

我试过;

    Mutex mutex = null;
    private string CreateOrder(string userName) {
        if (mutex == null) {
            mutex = new Mutex(true, userName);
        }
        mutex.WaitOne();
        // Code from above
        mutex.ReleaseMutex();
        mutex = null;
        return order;
    }

这可行，但在某些情况下它会挂在 WaitOne 上，我不知道为什么。是否有错误，或者我应该使用其他方法来锁定？

谢谢

Answer 1

在 mutex 构造函数中为 initiallyOwned 传递 false。如果您创建互斥锁并最初拥有它，则需要再次调用 ReleaseMutex。

Answer 2

释放互斥体时，您应该始终尝试最后。另外，请确保密钥正确（用户名）

Mutex mutex = null;
private string CreateOrder(string userName) {
    mutex = mutex ?? new Mutex(true, userName);
    mutex.WaitOne();
    try{
    // Code from above
    }finally{
    mutex.ReleaseMutex();
    }
    mutex = null;
    return order;
}

Answer 3

在您的代码中，您正在惰性地创建互斥体。这会导致竞争条件。
例如，当您从另一个线程调用 WaitOne() 时，可能会发生互斥体仅部分构造的情况。
您也可能创建两个互斥体实例。
等等...

您可以通过急切地创建实例来避免这种情况 - 即如迈克尔的代码所示。
（确保将其初始化为非拥有状态。）

Mutex 是内核级同步原语 - 它比 Monitor 更昂贵（这就是 lock 使用的功能。）。

Answer 4

除非我漏掉了什么，否则你不能用普通的锁吗？

private object _locker = new object();

private string CreateOrder(string userName)
{
    lock(_locker)
    {
        // Fetch current order
        Order order = FetchOrder(userName);
        if (order.OrderId == 0)
        {
            // Has no order yet, create a new one
            order.OrderNumber = Utility.GenerateOrderNumber();
            order.Save();
        }
        return order;
    }
}

Answer 5

我一直避免锁定基于 Web 的应用程序 - 让 Web 服务器处理线程，而是构建重复检测。

您认为通过锁定 CreateOrder 会得到什么？在我看来，您可以避免同时创建两个订单，但最终仍然会创建两个订单。

Answer 6

这样做更容易：

在某个地方定义一个类，如下所示：

public class MyLocks {
    public static object OrderLock;
    static MyLocks() {
        OrderLock = new object();
    }
}

然后在使用锁时执行以下操作：

lock(MyLocks.OrderLock) {
    // put your code here
}

那么它不是很复杂。无论出于何种目的定义锁都是轻量级的，因为它们只是内存中非常小的对象，在多个线程中都处于活动状态。