Concurrent Collection in C# | Multithreaded Collection in C#
Concurrent collections in C# are
designed to handle multiple threads accessing and modifying collections
simultaneously without causing data corruption or inconsistencies. These
collections are part of the System.Collections.Concurrent namespace and provide thread-safe operations for common
collection types.
Types
of Concurrent Collections
1.
ConcurrentDictionary<TKey, TValue>
Definition
A thread-safe collection of
key-value pairs, allowing efficient and safe operations for adding, updating,
and retrieving items concurrently.
Syntax
csharp
ConcurrentDictionary<TKey,
TValue> dictionary = new ConcurrentDictionary<TKey, TValue>();
Example
csharp
using System;
using System.Collections.Concurrent;
class Program
{
static ConcurrentDictionary<int, string> dictionary = new
ConcurrentDictionary<int, string>();
static void Main()
{
dictionary.TryAdd(1, "One");
dictionary.TryAdd(2, "Two");
dictionary.AddOrUpdate(1,
"Uno", (key, oldValue) => "Uno");
foreach (var kvp in dictionary)
{
Console.WriteLine($"Key:
{kvp.Key}, Value: {kvp.Value}");
}
}
}
Advantages
- Thread-Safe:
Allows concurrent read and write operations.
- Efficient:
Uses fine-grained locking to improve performance.
- Atomic Operations:
Provides methods for atomic updates.
2.
ConcurrentQueue<T>
Definition
A thread-safe FIFO
(First-In-First-Out) collection that allows multiple threads to enqueue and
dequeue items safely.
Syntax
csharp
ConcurrentQueue<T> queue = new
ConcurrentQueue<T>();
Example
csharp
using System;
using System.Collections.Concurrent;
class Program
{
static
ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
static void Main()
{
queue.Enqueue(1);
queue.Enqueue(2);
if (queue.TryDequeue(out int result))
{
Console.WriteLine($"Dequeued:
{result}");
}
}
}
Advantages
- Non-Blocking:
Enqueue and TryDequeue operations do not block.
- Thread-Safe:
Allows safe concurrent access.
- Performance:
Suitable for high-throughput scenarios.
3.
ConcurrentStack<T>
Definition
A thread-safe LIFO
(Last-In-First-Out) collection that allows multiple threads to push and pop
items safely.
Syntax
csharp
ConcurrentStack<T> stack = new
ConcurrentStack<T>();
Example
csharp
using System;
using System.Collections.Concurrent;
class Program
{
static ConcurrentStack<int> stack = new
ConcurrentStack<int>();
static void Main()
{
stack.Push(1);
stack.Push(2);
if (stack.TryPop(out int result))
{
Console.WriteLine($"Popped:
{result}");
}
}
}
Advantages
- Non-Blocking:
Push and TryPop operations do not block.
- Thread-Safe:
Allows safe concurrent access.
- Performance:
Efficient for stack-based operations.
4.
ConcurrentBag<T>
Definition
A thread-safe, unordered collection
that allows multiple threads to safely add and remove items.
Syntax
csharp
ConcurrentBag<T> bag = new
ConcurrentBag<T>();
Example
csharp
using System;
using System.Collections.Concurrent;
class Program
{
static ConcurrentBag<int> bag = new ConcurrentBag<int>();
static void Main()
{
bag.Add(1);
bag.Add(2);
foreach (var item in bag)
{
Console.WriteLine($"Item:
{item}");
}
}
}
Advantages
- Optimized for Add and Remove: Efficient for adding and removing items.
- Thread-Safe:
Allows safe concurrent access.
- Unordered Collection:
Suitable for scenarios where order does not matter.
5.
BlockingCollection<T>
Definition
A thread-safe collection that
provides blocking and bounding capabilities. It can block adding or taking
items if the collection is full or empty, respectively.
Syntax
csharp
BlockingCollection<T>
collection = new BlockingCollection<T>();
Example
csharp
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
class Program
{
static BlockingCollection<int> collection = new
BlockingCollection<int>(new ConcurrentQueue<int>(), 5);
static void Main()
{
Task.Run(() =>
{
foreach (int item in collection.GetConsumingEnumerable())
{
Console.WriteLine($"Consumed: {item}");
}
});
for (int i = 0; i < 5; i++)
{
collection.Add(i);
Console.WriteLine($"Produced:
{i}");
}
collection.CompleteAdding();
}
}
Advantages
- Bounded Capacity:
Allows setting a maximum capacity.
- Blocking Operations:
Add and Take methods can block.
- Versatile Usage:
Can be used with any collection implementing IProducerConsumerCollection<T>.
.webp)
POST Answer of Questions and ASK to Doubt