ConcurrentStack：如何检查是否包含对象？

Question

How can i check if it contains specific object in the stack ?

private ConcurrentStack<int> cs = new ConcurrentStack<int>();
cs.Push(1);

Answer 1

The method Stack<T>.Contains isn't available in the ConcurrentStack<T> -class . I guess because that would not be thread-safe.

So if you needed it you had to use a lock, then you could use Enumerable.Contains :

private ConcurrentStack<int> cs = new ConcurrentStack<int>();
private Object csLockObject  = new Object();

...

bool contains = false;
lock (csLockObject)
{
    contains = cs.Contains(1);
}

But while you enumerate this snapshot it's possible that another thread adds or removes items to/from the stack. If you wanted to prevent that you also need a lock where you add/remove.

I want to avoid duplicates

Well, you could use a class like this which uses a ConcurrentDictionary to check if it's unique:

public class ConcurrentUniqueStack<T>
{
    private readonly ConcurrentDictionary<T, int> _itemUnique; // there is no ConcurrentHashSet so we need to use a Key-only dictionary
    private readonly ConcurrentStack<T> _stack;

    public ConcurrentUniqueStack() : this(EqualityComparer<T>.Default)
    {
    }
    public ConcurrentUniqueStack(IEqualityComparer<T> comparer)
    {
        _stack = new ConcurrentStack<T>();
        _itemUnique = new ConcurrentDictionary<T, int>(comparer);
    }

    public bool TryPush(T item)
    {
        bool unique = _itemUnique.TryAdd(item, 1);
        if (unique)
        {
            _stack.Push(item);
        }

        return unique;
    }
    public bool TryPop(out T result)
    {
        bool couldBeRemoved = _stack.TryPop(out result);
        if (couldBeRemoved)
        {
            _itemUnique.TryRemove(result, out int whatever);
        }
        return couldBeRemoved;
    }

    public bool TryPeek(out T result) => _stack.TryPeek(out result);
}

Answer 2

This structure is not optimized for this operation.

It means, that value lookup operation has O(N) complexity, because you have to iterate whole collection.

So answer depends of your requirements:

• If you want to check value sometimes (eg complexity is does not matter) - just use _stack.FirstOrDefault(v=> v==valueWhichYouTryToFind) . This can be slow, because you have to iterate all elements. However task will be solved. And please note, that stack can be changed before this function will be finished (eg this function can return true after stack pop operation will be finished)
• If you want to often check values inside huge stack - then you have to create complex structure with concurrent set + stack. I recommend (this is just my opinion) to use just simple Stack + HashSet + locks, because it is quite simpler.

Answer 3

Your problem has no easy answer. The reason is that ConcurrentStack is designed to be used in a multi-threaded environment, which comes with some caveats. The key issue is that your Contains operation has to be atomic. Let's explore the options you have:

1. Enumerate the stack

You could enumerate the stack with foreach and check if your value is in there. The problem is that this enumeration is not atomic and in a multi-threaded environment even dangerous, because a change of the stack from another thread within the enumeration will cause an InvalidOperationException . The LINQ method Enumerable.Contains makes no difference here, because it will also enumerate the stack.

You could simply place your enumeration inside a lock , which only works if all accesses to the stack (ie pushes and pops) are within the same lock. And then you don't need a ConcurrentStack . You can simply go with a regular Stack . Note that ConcurrentStack , ConcurrentQueue and ConcurrentBag are implemented lock-free. Placing them inside a lock negates this.

2. Peek the stack top

You can call TryPeek on the stack, which is is an atomic operation. The problem is that you will only get the value on the stack top. If this is fine for you, you can go with this solution. Otherwise you can't.

3. Pop and push the values

You could TryPopRange all the values from the stack and then TryPushRange the values back onto the stack. I've added this option merely for the sake of completeness, since it actually is totally crazy. When you pop all the values off the stack, they will not be there anymore until you push them back. If anyone wants to pop the top of the stack they are in bad luck. Even worse, when they push another value, you don't only miss it in your check, it will also shake up the stack order.

This all means that you again have to place the whole operation inside a lock, which you can have easier with option 1 (enumerating the stack).

Conclusion

If you need to only check the stack top, use TryPeek . If you need to check all values, use a Stack and place it inside a lock whenever you access it.