44

我需要根据一组有限的字符串在一个区域中创建一个关键部分。我希望为同一个字符串实例共享锁（有点类似于String.Intern方法）。

我正在考虑以下实现：

public class Foo
{
    private readonly string _s;
    private static readonly HashSet<string> _locks = new HashSet<string>();

    public Foo(string s)
    {
        _s = s;
        _locks.Add(s);
    }

    public void LockMethod()
    {
        lock(_locks.Single(l => l == _s))
        {
            ...
        }
    }
}

这种方法有什么问题吗？以这种方式锁定字符串对象是否可以，并且在使用中是否存在任何线程安全问题HashSet<string>？

例如，创建一个Dictionary<string, object>为每个字符串实例创建一个新的锁对象会更好吗？

最终实施

根据我的建议，我采用了以下实现：

public class Foo
{
    private readonly string _s;
    private static readonly ConcurrentDictionary<string, object> _locks = new ConcurrentDictionary<string, object>();

    public Foo(string s)
    {
        _s = s;
    }

    public void LockMethod()
    {
        lock(_locks.GetOrAdd(_s, _ => new object()))
        {
            ...
        }
    }
}
4

4 回答 4

29

不鼓励锁定字符串，主要原因是（由于字符串实习）一些其他代码可能会在您不知道的情况下锁定同一个字符串实例。造成死锁情况的可能性。

现在，在大多数具体情况下，这可能是一个牵强的场景。这更像是图书馆的一般规则。

但另一方面，字符串的感知好处是什么？

所以，点对点：

这种方法有什么问题吗？

是的，但主要是理论上的。

以这种方式锁定字符串对象是否可以，使用HashSet是否存在线程安全问题？

HashSet<>只要线程只并发读取，线程安全就不会涉及。

例如，创建一个为每个字符串实例创建一个新锁对象的 Dictionary 是否更好？

是的。只是为了安全起见。在大型系统中，避免死锁的主要目的是使锁定对象尽可能地保持本地和私有。只有有限数量的代码应该能够访问它们。

于 2012-10-09T17:03:58.050 回答
24

就个人而言，我会说这是一个非常糟糕的主意。那不是字符串的用途。

（我个人不喜欢每个对象首先都有一个监视器的事实，但这是一个稍微不同的问题。）

如果您想要一个表示可以在不同实例之间共享的锁的对象，为什么不为此创建一个特定类型呢？您可以轻松地为锁命名以用于诊断目的，但锁定实际上不是字符串的目的。像这样的东西：

public sealed class Lock
{
    private readonly string name;

    public string Name { get { return name; } }

    public Lock(string name)
    {
        if (name == null)
        {
            throw new ArgumentNullException("name");
        }
        this.name = name;
    }
}

考虑到字符串有时会被保留，有时不会（通过简单的检查有时很难辨别），您可能很容易意外地在您不打算使用它们的地方共享锁。

于 2012-10-09T17:04:09.487 回答
6

锁定字符串可能会有问题，因为实习字符串本质上是全局的。

内部字符串是每个进程的，因此它们甚至在不同的 AppDomain 之间共享。类型对象也是如此（所以不要锁定 typeof(x)）。

于 2012-10-09T17:04:04.973 回答
3

不久前我遇到了一个类似的问题，我正在寻找一种基于字符串值锁定一段代码的好方法。这就是我们目前所拥有的，它解决了内部字符串的问题并具有我们想要的粒度。

主要思想是使用字符串键维护同步对象的静态ConcurrentDictionary。当一个线程进入该方法时，它会立即建立一个锁并尝试将同步对象添加到并发字典中。如果我们可以添加到并发字典中，这意味着没有其他线程拥有基于我们的字符串键的锁，我们可以继续我们的工作。否则，我们将使用并发字典中的同步对象来建立第二个锁，它将等待正在运行的线程完成处理。当第二个锁被释放时，我们可以尝试再次将当前线程的同步对象添加到字典中。

需要注意的是：线程没有排队——因此，如果具有相同字符串键的多个线程同时竞争锁，则无法保证它们的处理顺序。

如果您认为我忽略了某些内容，请随时批评。

public class Foo
{
    private static ConcurrentDictionary<string, object> _lockDictionary = new ConcurrentDictionary<string, object>();

    public void DoSomethingThreadCriticalByString(string lockString)
    {
        object thisThreadSyncObject = new object();

        lock (thisThreadSyncObject)
        {
            try
            {
                for (; ; )
                {
                   object runningThreadSyncObject = _lockDictionary.GetOrAdd(lockString, thisThreadSyncObject);
                   if (runningThreadSyncObject == thisThreadSyncObject)
                       break;

                    lock (runningThreadSyncObject)
                    {
                        // Wait for the currently processing thread to finish and try inserting into the dictionary again.
                    }
                }

                // Do your work here.

            }
            finally
            {
                // Remove the key from the lock dictionary
                object dummy;
                _lockDictionary.TryRemove(lockString, out dummy);
            }
        }
    }
}
于 2016-05-29T22:21:14.227 回答