Thread Safe Concurrent Collection in C#

The .NET Framework 4 brought the System.Collections.Concurrent namespace. This has several collection classes that are thread-safe and scalable. These collections are called concurrent collections because they can be accessed by multiple threads at a time.

The following are the concurrent collection in C# −

Sr.No	Type & Description
1	BlockingCollection<T> Bounding and blocking functionality for any type.
2	ConcurrentDictionary<TKey,TValue> Thread-safe implementation of a dictionary of key-value pairs.
3	ConcurrentQueue<T> Thread-safe implementation of a FIFO (first-in, first-out) queue.
4	ConcurrentStack<T> Thread-safe implementation of a LIFO (last-in, first-out) stack.
5	ConcurrentBag<T> Thread-safe implementation of an unordered collection of elements.
6	IProducerConsumerCollection<T> The interface that a type must implement to be used in a BlockingCollection

Let us see how to work with ConcurrentStack<T> that is a thread-safe last in-first out (LIFO) collection.

Create a ConcurrentStack.

ConcurrentStack<int> s = new ConcurrentStack<int>();

Add elements

s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
s.Push(5);
s.Push(6);

Let us see an example

Example

using System;
using System.Collections.Concurrent;

class Demo{
   static void Main (){
      ConcurrentStack s = new ConcurrentStack();

      s.Push(50);
      s.Push(100);
      s.Push(150);
      s.Push(200);
      s.Push(250);
      s.Push(300);

      if (s.IsEmpty){
         Console.WriteLine("The stack is empty!");
      }

      else {
         Console.WriteLine("The stack isn't empty");
      }
   }
}