Locking HashSet for concurrency [duplicate]

Answer 1

No, as others stated, it isn't thread-safe to do what you're doing. If the underlying collection isn't thread-safe, you will need to lock on every operation.

When using a HashSet<T>, there need not be a ContainsKey check, as Add will check if the internal collection already contains the value or not:

Return Value Type: System.Boolean

true if the element is added to the HashSet object; false if the element is already present.

So you can narrow your code to:

private readonly object syncRoot = new object();
lock (syncRoot)
    hashSet.Add(value);

Answer 2

What is the point of those calls to Contains()? They don't do anything. If you want to add only if the set does not contain an item, then you can do the following:

if(!hasSet.Contains(h))
{
   lock(hashSetLock)
   {
      if(!hasSet.Contains(h))
      {
         hashSet.Add(h);
      }
   }
}

With this code you don't lock to check the existing of the element, but if the element was not set you have to check again after locking. What do you gain? You don't lock in case the element already exists.

Answer 3

No, it is not sufficient to lock only on Add.

The fact that it doesn't crash only tells you that it didn't crash during your test.

You cannot guarantee that:

• It won't crash in the future
• It will produce the correct results

A non-threadsafe data structure has no guarantees whatsoever if used in a multithreaded fashion.

You need to either:

• Lock on every call to it
• Use a threadsafe data structure, one that has been built to support this scenario

If you use a different data structure than a hashset, like a dictionary, you may even need to lock multi-statements, because this may still fail:

lock (dLock)
    if (d.ContainsKey("test"))
        return;

var value = ExpensiveCallToObtainValue();
lock (dLock)
    d.Add("test", value);

Between the call to ContainsKey and the call to Add another thread may have already inserted that key.

To handle this correctly, without using a threadsafe data structure, is contain both operations inside the same lock:

lock (dLock)
{
    if (!d.ContainsKey("test"))
        d.Add("test", ExpensiveCallToObtainValue());
}