M B A R K's Blog
ConcurrentBag in C#

ConcurrentBag in C#

M B A R K's photo
M B A R K
·

2 min read

Table of contents

ConcurrentBag is a thread-safe collection type in the System.Collections.Concurrent namespace of the .NET framework. It is a bag data structure that allows multiple threads to add and remove items concurrently, without the need for locking.

How it works

ConcurrentBag is implemented using lock-free algorithms, which means that it does not use locks to synchronize access to the collection. Instead, it uses low-level atomic operations to update the collection in a thread-safe manner. This makes ConcurrentBag highly efficient, as it does not suffer from the overhead of acquiring and releasing locks.

How to use ConcurrentBag

Using ConcurrentBag is straightforward. You can create an instance of the collection and add items to it using the Add method:

ConcurrentBag<int> bag = new ConcurrentBag<int>();

bag.Add(1);
bag.Add(2);
bag.Add(3);

You can also remove items from the bag using the TryTake method:

int item;
if (bag.TryTake(out item))
{
    Console.WriteLine(item); // Outputs a randomly chosen item from the bag
}

Example: Producer-Consumer pattern

ConcurrentBag is often used in the producer-consumer pattern, where multiple producer threads add items to the collection and multiple consumer threads remove items from it.

Here is an example of how you can use ConcurrentBag to implement a producer-consumer pattern in C#:

using System;
using System.Collections.Concurrent;
using System.Threading;

class Program
{
    static ConcurrentBag<int> bag = new ConcurrentBag<int>();

    static void Main()
    {
        // Start the producer thread
        Thread producer = new Thread(Produce);
        producer.Start();

        // Start the consumer thread
        Thread consumer = new Thread(Consume);
        consumer.Start();

        // Wait for the threads to finish
        producer.Join();
        consumer.Join();
    }

    static void Produce()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Produced: " + i);
            bag.Add(i);
            Thread.Sleep(100);
        }
    }

    static void Consume()
    {
        while (true)
        {
            int item;
            if (bag.TryTake(out item))
            {
                Console.WriteLine("Consumed: " + item);
            }
            else
            {
                break;
            }
        }
    }
}

In this example, the Produce method adds 10 items to the bag, and the Consume method continuously removes items from the bag until it is empty.

Conclusion

ConcurrentBag is a useful collection type in the .NET framework that allows you to add and remove items concurrently, without the need for locking. It is particularly well-suited for the producer-consumer pattern, where multiple threads add and remove items from the collection concurrently.

C#