使用字符串作为锁做线程同步

Question

在查看一些遗留应用程序代码时，我注意到它使用字符串对象进行线程同步。我正在尝试解决该程序中的一些线程争用问题，并且想知道这是否会导致一些奇怪的情况。有什么想法吗 ？

private static string mutex= "ABC";

internal static void Foo(Rpc rpc)
{
    lock (mutex)
    {
        //do something
    }
}

Answer 1

这样的字符串（来自代码）可能是“interned”。这意味着“ABC”的所有实例都指向同一个对象。即使跨越AppDomains，您也可以指向同一个对象（感谢 Steven 的提示）。

如果您有很多字符串互斥体，来自不同的位置，但具有相同的文本，它们都可以锁定在同一个对象上。

实习生池保存字符串存储。如果将文字字符串常量分配给多个变量，则每个变量都设置为引用实习池中的相同常量，而不是引用具有相同值的多个不同 String 实例。

最好用：

 private static readonly object mutex = new object();

另外，由于您的字符串不是const 或readonly，您可以更改它。所以（理论上）可以锁定你的mutex。将mutex 更改为另一个引用，然后进入临界区，因为锁使用了另一个对象/引用。示例：

private static string mutex = "1";
private static string mutex2 = "1";  // for 'lock' mutex2 and mutex are the same

private static void CriticalButFlawedMethod() {
    lock(mutex) {
      mutex += "."; // Hey, now mutex points to another reference/object
      // You are free to re-enter
      ...
    }
}

Answer 2

为了回答您的问题（正如其他人已经提出的那样），您提供的代码示例存在一些潜在问题：

private static string mutex= "ABC";

• 变量mutex 不是不可变的。
• 字符串文字 "ABC" 将在您的应用程序的任何地方引用相同的内部对象引用。

一般来说，我建议不要锁定字符串。但是，我遇到了一个有用的案例。

在某些情况下，我维护了一个锁定对象字典，其中的键是我所拥有的某些数据的独特之处。这是一个人为的例子：

void Main()
{
    var a = new SomeEntity{ Id = 1 };
    var b = new SomeEntity{ Id = 2 };

    Task.Run(() => DoSomething(a));    
    Task.Run(() => DoSomething(a));    
    Task.Run(() => DoSomething(b));    
    Task.Run(() => DoSomething(b));
}

ConcurrentDictionary<int, object> _locks = new ConcurrentDictionary<int, object>();    
void DoSomething(SomeEntity entity)
{   
    var mutex = _locks.GetOrAdd(entity.Id, id => new object());

    lock(mutex)
    {
        Console.WriteLine("Inside {0}", entity.Id);
        // do some work
    }
}   

这样的代码的目标是在实体的Id 的上下文中序列化DoSomething() 的并发调用。缺点是字典。实体越多，它就越大。这也是需要阅读和思考的更多代码。

我认为 .NET 的字符串实习可以简化事情：

void Main()
{
    var a = new SomeEntity{ Id = 1 };
    var b = new SomeEntity{ Id = 2 };

    Task.Run(() => DoSomething(a));    
    Task.Run(() => DoSomething(a));    
    Task.Run(() => DoSomething(b));    
    Task.Run(() => DoSomething(b));
}

void DoSomething(SomeEntity entity)
{   
    lock(string.Intern("dee9e550-50b5-41ae-af70-f03797ff2a5d:" + entity.Id))
    {
        Console.WriteLine("Inside {0}", entity.Id);
        // do some work
    }
}

这里的区别是我依靠字符串实习来为每个实体 ID 提供相同的对象引用。这简化了我的代码，因为我不必维护互斥体实例的字典。

请注意我用作命名空间的硬编码 UUID 字符串。如果我选择在我的应用程序的另一个区域采用相同的方法锁定字符串，这一点很重要。

根据情况和开发人员对细节的关注程度，锁定字符串可能是个好主意或坏主意。

Answer 3

如果您需要锁定字符串，您可以创建一个对象，将字符串与您可以锁定的对象配对。

class LockableString
{
     public string _String; 
     public object MyLock;  //Provide a lock to the data in.

     public LockableString()
     {
          MyLock = new object();
     }
}

Answer 4

我的 2 美分：

1. ConcurrentDictionary 比内部字符串快 1.5 倍。我做过一次基准测试。

2. 要解决“不断增长的字典”问题，您可以使用信号量字典而不是对象字典。 AKA 使用 ConcurrentDictionary<string, SemaphoreSlim> 而不是 <string, object>。与lock 语句不同，信号量可以跟踪锁定它们的线程数。一旦所有的锁都被释放 - 你可以从字典中删除它。请参阅此问题以获取此类解决方案：Asynchronous locking based on a key

3. 信号量更好，因为您甚至可以控制并发级别。就像，而不是“限制为一个并发运行” - 您可以“限制为 5 个并发运行”。很棒的免费奖金不是吗？我必须编写一个电子邮件服务，该服务需要限制与服务器的并发连接数 - 这非常方便。

Answer 5

我想如果生成的字符串很多并且都是唯一的，那么锁定实习字符串可能会导致内存膨胀。另一种应该提高内存效率并解决直接死锁问题的方法是

// Returns an Object to Lock with based on a string Value
private static readonly ConditionalWeakTable<string, object> _weakTable = new ConditionalWeakTable<string, object>();
public static object GetLock(string value)
{
    if (value == null) throw new ArgumentNullException(nameof(value));
    return _weakTable.GetOrCreateValue(value.ToLower());
}