Block a Concurrent Collection such as a ConcurrentBag or BlockingCollection

Question

I want to execute two statements accessing a ConcurrentBag without any other thread accessing it in between. For example:

ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();
concurrentBag.Add(1);
int check = 0;
//Somehow block so that the following two statements will 
//be executed without any other thread accessing concurrentBag.
concurrentBag.TryPeek(out check);
if (check == 2) concurrentBag.Add(3);

how can that be done?

Answer 1

If you mean that you want to unconditionally block any other thread from accessing some object, then you simply can't do it. That is, if you have some object:

public Object foo = new Object();

There is nothing you can do in your thread to prevent other threads from accessing foo. A lock won't work, as you pointed out, because a lock is a cooperative mutual exclusion device. Nothing except convention prevents somebody from writing code that ignores the lock and accesses the object.

You could conceivably wrap the object in a class that enforces mutual exclusion, but then all you're doing is adding a lock or something similar. Even then, you'd have to create a special method that implements the semantics you're looking for (i.e. peek-and-add). And even that isn't foolproof because somebody could use reflection to access the underlying data structure directly.

Your peek-and-add operation is a bit unusual. I don't know enough about your application to say for sure, but in most cases there's a more conventional way to implement the functionality you want. This is particularly true with something like ConcurrentBag, where Peek will give different results depending on which thread is accessing it.

Answer 2

I suspect this is going to be significantly harder than just wrapping a few lines of code with the lock keyword. The reason being that you would have to wrap all access to the ConcurrentBag with a lock. And if you did that then it would not be "concurrent" anymore. I think what you are asking for is a way to temporarily suspend the concurrent behavior of the collection in favor of a serialized behavior and then resume its concurrent behavior once again when you have completed a special guarded operation.

The naive approach would be to create your own collection that provides the same operations as ConcurrentBag by using it internally as the underlying collection. You would then provide SuspendConcurrent and ResumeConcurrent operations that toggle the concurrent behavior of the collection by setting and resetting a flag (probably via the Interlocked.CompareExchange method). The code would then use this flag to determine whether to directly forward Add, TryPeek, and TryTake operations to the underlying collection or use a hard lock before doing so. I think in the end you will find the code very complex and incredibly hard to get right. Based on personal experience any trivial implementation you are envisioning right now will probably either be wrong, be inefficient, or not be fully concurrent when you want it to be.

My advice is to figure out a way to restructure your code so that this requirement goes away.

Edit:

From one of your comments it seems as though you want a CAS like operation to be able to make a decision based on whether or not something has already occurred. There are several options, but one which might best suit your needs is to use the ConcurrentDictionary class which provides the TryAdd method. TryAdd will return true if the key does not yet exist. If the key does exist then it will return false. Many threads can be executing this method simultaneously with the same key, but only one will get the true response. You can then use an if statement to control program flow based on the return value.

Answer 3

static object syncLock = new object();
ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();
concurrentBag.Add(1);
int check = 0;
lock(syncLock)
{
    concurrentBag.TryPeek(out check);
    if (check == 2) concurrentBag.Add(3);
}