Question

我有一个可以在C ++中轻松解决的问题，但在C＃中我还是找不到一个好的解决方案：

我有一个需要锁定两个对象的函数foo，并且可以使用相反顺序的参数调用此函数，例如：

    static void foo(object o1, object o2)
    {
        lock (o1)
        {
            lock (o2)
            {
                ...
            }
        }
    }

    static void bar(object a, object b)
    {
        ThreadPool.QueueUserWorkItem(s => foo(a, b));
        ThreadPool.QueueUserWorkItem(s => foo(b, a));
    }

这是一种解决僵局的方法。解决此问题的标准方法是始终以相同的顺序锁定对象。在C ++中，我可以比较指针，但在“安全”C＃中，我不知道任何方式，只是一个非常丑陋的Monitor.TryEntry解决方案（见下文）。有更好的吗？请注意，对象是可变的，我不能依赖Equals，GetHashCode，IComparable。

    static void foo(object o1, object o2)
    {
        const int Timeout = 1000;
        while (true)
        {
            if (Monitor.TryEnter(o1, Timeout))
            {
                try
                {
                    if (Monitor.TryEnter(o2, Timeout))
                    {
                        try
                        {
                            ...
                            return;
                        }
                        finally
                        {
                            Monitor.Exit(o2);
                        }
                    }
                }
                finally
                {
                    Monitor.Exit(o1);
                }
            }
        }
    }

Answer 1

如果您想要相同的有序锁定方法，您可以向用于锁定的对象添加一些属性，并根据它进行比较。您可以根据您的情况使用类或接口（即在锁定对象上实现IComparable）。下面的示例使用具有Less比较函数的类：

class ComparableLockingObject
{
    static int LastOrderValue = 0;
    private orderValue = LastOrderValue++;

    public bool Less(ComparableLockingObject other)
    {
       return this.orderValue < other.orderValue;
    }
}

static void foo(ComparableLockingObject o1, ComparableLockingObject o2,
    Action action)
{
   if (o2.Less(o1))
   {
      var temp = o1;
      o1 = o2;
      o2 = temp;
   }

   lock (o1)
   {
        lock (o2)
        {
           action();
        }
    }
}

Answer 2

您无需锁定这些对象。您锁定执行逻辑的代码：

  static object lockObject = new object();
  static void foo(object o1, object o2)
  {
     lock (lockObject)
     {
        // this code will be executed on one thread at the time. Why lock o1 & o2??
     }
  }

锁定两个没有死锁的对象

2 个答案: