Thread-Safe collections in C#

In this article, we will learn:

What is a Concurrent collection in C# ?

BlockingCollection<T>

ConcurrentBag<T>

ConcurrentDictionary<TKey,T>

ConcurrentStack<T>

ConcurrentQueue<T>

Summary

What is a Concurrent collection in C# ?

While working in a multithreaded environment, we need to make sure that we are not manipulating shared data at the same time without synchronizing access.

The .NET Framework offers some collection classes to use in concurrent environments. Those are:

These collections are thread-safe, that means they internally use synchronization to make sure that they can be accessed by multiple threads at the same time.

BlockingCollection<T> :

This collection is mainly used for adding and removing data.

Removing an item from the collection can be blocked until data becomes available.

Adding data is fast, but you can set a maximum upper limit. If that limit is reached, adding an item blocks the calling thread until there is room.

BlockingCollection is actually a wrapper around other collection types. If you don’t give it any specific instructions, it uses the ConcurrentQueue by default.

Working with BlockingCollection<T> :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
 
namespace ConcurrentCollectionExample
{
    public static class ConcurrentCollectionProgram
    {
        public static void Main()
        {
            BlockingCollection<string> col = new BlockingCollection<string>();
            Task read = Task.Run(() =>
            {
                while (true)
                {
                    Console.WriteLine(col.Take());
                }
            });
            Task write = Task.Run(() =>
            {
                while (true)
                {
                    string s = Console.ReadLine();
                    if (string.IsNullOrWhiteSpace(s)) break;
                    col.Add(s);
                }
            });
            write.Wait();
        }
    }
}

The program terminates when the user doesn’t enter any data.

Until that, every string entered is added by the write Task and removed by the read Task.
You can use the CompleteAdding method to signal to the BlockingCollection that no more items will be added.

ConcurrentBag<T> :

A ConcurrentBag is a bag of items. It enables duplicates and it has no particular order.The important methods in Concurrentbag are Add, TryTake, and TryPeek.

Working with ConcurrentBag<T> :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
 
namespace ConcurrentCollectionExample
{
    public static class ConcurrentCollectionProgram
    {
        public static void Main()
        {
            ConcurrentBag<int> bag = new ConcurrentBag<int>();
            bag.Add(53);
            bag.Add(12);
            int result;
            if (bag.TryTake(out result))
            Console.WriteLine(result);
                if (bag.TryPeek(out result))
                Console.WriteLine("There is a next item: {0}", result);
        }
    }
}

Output:

12
There is a next item : 53

Note, TryPeek method is not very useful in a multithreaded environment. It could be that another thread removes the item before you can access it

ConcurrentBag also implements IEnumerable, so you can iterate over it.
This operation is made thread-safe by making a snapshot of the collection when you start iterating it, so items added to the collection after you started iterating it won’t be visible.

Enumerating a ConcurrentBag:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;
 
namespace ConcurrentCollectionExample
{
    public static class ConcurrentCollectionProgram
    {
        public static void Main()
        {
            ConcurrentBag<int> bag = new ConcurrentBag<int>();
            Task.Run(() =>
            {
                bag.Add(53);
                Thread.Sleep(1000);
                bag.Add(12);
            });
            Task.Run(() =>
            {
                foreach (int i in bag)
                    Console.WriteLine(i);
            }).Wait();
        }
    }
}

Output:

This program will print 53 because the other value is added after iterating over the bag has started.

ConcurrentDictionary<T> :

A ConcurrentDictionary stores key and value pairs in a thread-safe manner. You can use methods to add and remove items, and to update items in place if they exist.

Working with ConcurrentDictionary<Tkey,T> :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;
 
namespace ConcurrentCollectionExample
{
    public static class ConcurrentCollectionProgram
    {
        public static void Main()
        {
            var dict = new ConcurrentDictionary<string, int>();
            if (dict.TryAdd("k1", 53))
            {
            Console.WriteLine("Added");
            }
            if (dict.TryUpdate("k1", 12, 53))
            {
            Console.WriteLine("53 updated to 12");
            }
            dict["k1"] = 53; // Overwrite unconditionally
            int r1 = dict.AddOrUpdate("k1", 3, (s, i) => i * 2);
            int r2 = dict.GetOrAdd("k2", 3);
        }
    }
}

Output:

This program will print:
Added
53 updated to 12

ConcurrentStack<T> :

A stack is a last in, first out (LIFO) collection.

ConcurrentStack has two main methods: Push and TryPop.
Push is used to add an item to the stack and TryPop is used to get an item off the stack.

You can never be sure whether there are items on the stack because multiple threads might be accessing your collection at the same
time.

You can also add and remove multiple items at once by using PushRange and TryPopRange.

Working with ConcurrentStack<T> :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;
 
namespace ConcurrentCollectionExample
{
    public static class ConcurrentCollectionProgram
    {
        public static void Main()
        {
           ConcurrentStack<int> stack = new ConcurrentStack<int>();
            stack.Push(53);
            int result;
            if (stack.TryPop(out result))
            Console.WriteLine("Popped: {0}", result);
            stack.PushRange(new int[] { 1, 2, 3 });
            int[] values = new int[2];
            stack.TryPopRange(values);
            foreach (int i in values)
            Console.WriteLine(i);
        }
    }
}

Output:

Popped: 53
3
2

ConcurrentQueue<T> :

A queue is a first in, first out (FIFO) collection.

ConcurrentQueue has 2 main methods: Enqueue and TryDequeue.
Enqueue and TryDequeue is used to add and remove items from the collection.

It also has a TryPeek method and it implements IEnumerable by making a snapshot of the data.

Working with ConcurrentQueue<T> :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;
 
namespace ConcurrentCollectionExample
{
    public static class ConcurrentCollectionProgram
    {
        public static void Main()
        {
           ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
            queue.Enqueue(53);
            int result;
            if (queue.TryDequeue(out result))
            Console.WriteLine("Dequeued: {0}", result);
        }
    }
}

Output:

Dequeued: 53

Summary:

In this article, we have discussed:

What is a Concurrent collections in C# ?
BlockingCollection<T>
ConcurrentBag<T>
ConcurrentDictionary<TKey,T>
ConcurrentQueue<T>
ConcurrentStack<T>

Software Solutions and RnD

2016-04-28

About_CSharp-ThreadSafeCollections

Thread-Safe collections in C#

In this article, we will learn:

What is a Concurrent collection in C# ?

BlockingCollection<T> :

Working with BlockingCollection<T> :

ConcurrentBag<T> :

Working with ConcurrentBag<T> :

Output:

Enumerating a ConcurrentBag:

Output:

ConcurrentDictionary<T> :

Working with ConcurrentDictionary<Tkey,T> :

Output:

ConcurrentStack<T> :

Working with ConcurrentStack<T> :

Output:

ConcurrentQueue<T> :

Working with ConcurrentQueue<T> :

Output:

Summary:

No comments:

HTMLCode

Previous Posts

Search This Blog

About this weblog

Labels

Links

About Me

Followers