https:\/\/blogs.msdn.com\/bclteam\/archive\/2005\/03\/15\/396399.aspx<\/font><\/a> for a discussion of these design issues. \n<\/p>\nBecause of all of these reasons, the generic collections introduced in .NET Framework 2.0 do not offer a mechanism of synchronization anymore (i.e. they don’t provide a static Synchronized method), forcing the developers to do the synchronization manually. \n<\/p>\n
Parallel Extensions to the .NET Framework aims to fill this gap by introducing new thread-safe generic collections that don’t suffer from the same issues as their antiquated “Synchronized” relatives. ConcurrentStack<T> is one of them. \n<\/p>\n
In the current moment ConcurrentStack<T> is implemented as a LIFO linked list and uses an interlocked compare exchange for the Push and Pop actions. However, it not recommended as the user to rely on the internal implementation details. \n<\/p>\n
The main and most used methods of a stack data structure are usually Push, Pop, and Peek. A quick look at ConcurrentStack<T> will show that it provides Push, but not Pop and Peek: instead, it provides a TryPop and TryPeek instead. This is quite intentional. One of the most common patterns when using a Stack<T> is to check the stack’s Count, and if it’s greater than 0, pop an item from it and use that item, e.g.: \n<\/p>\n
\nT item;
if (s.Count > 0)
{
item = s.Pop();
UseData(item);
}<\/p>\n<\/blockquote>\n
But in a world where this stack is being accessed by multiple threads concurrently, even if the individual Count and Pop methods were thread-safe, we still run into the issue that the stack could be emptied between a successful non-emptiness check and the attempt to pop. ConcurrentStack<T> takes this into account in the APIs it provides. To safely attempt to pop an item from the stack, we can instead write the code: \n<\/p>\n
\nT item;
if (s.TryPop(out item))
{
UseData(item);
}<\/p>\n<\/blockquote>\n
In this way using a ConcurrentStack<T> a producers\/consumer scenario could be implemented like below: \n<\/p>\n
\/\/initialize an empty concurrent stack<\/p>\n<\/span><\/p>\n
ConcurrentStack<string<\/span>> m_myConcurrentStack = new<\/span> ConcurrentStack<string<\/span>>();<\/p>\n<\/span><\/p>\n
\/\/every producer will produce this number of elements<\/p>\n<\/span><\/p>\n
<\/span>const<\/span> int<\/span> COUNT = 10;<\/span><\/p>\n<\/span> <\/span>public<\/span> void<\/span> ConsumeDataFromStack()<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>\/\/create the producers<\/p>\n<\/span><\/span><\/p>\n
<\/span>for<\/span> (int<\/span> i = 0; i < COUNT; i++)<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>Thread<\/span> currentProducer = new<\/span> Thread<\/span>(new<\/span> ThreadStart<\/span>(delegate<\/span>()<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>for(int<\/span> currentIndex = COUNT; currentIndex > 0; currentIndex–)<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>m_myConcurrentStack.Push(<\/p>\n<\/span><\/p>\n
<\/span>Thread<\/span>.CurrentThread.ManagedThreadId.ToString() + “_”<\/span> + <\/p>\n<\/span><\/p>\n
<\/span>currentIndex.ToString());<\/p>\n<\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/span>}));<\/p>\n<\/span><\/p>\n
<\/span>currentProducer.Start();<\/p>\n<\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/p>\n<\/span><\/p>\n
<\/span>\/\/allow the worker threads to start<\/p>\n<\/span><\/p>\n
<\/span>Thread<\/span>.Sleep(500);<\/span><\/p>\n<\/span><\/p>\n
<\/span>\/\/consume data<\/p>\n<\/span><\/span><\/p>\n
<\/span>string<\/span> currentData = “”<\/span>;<\/p>\n<\/span><\/p>\n
<\/span>while<\/span> (m_myConcurrentStack.TryPop(out<\/span> currentData))<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>\/\/ConsumeData(currentData);<\/p>\n<\/span><\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/span>}<\/span><\/p>\nPLINQ queries over a concurrent stack<\/b> \n<\/p>\n
Being an IEnumerable<T> a concurrent stack can be used as data source in PLINQ queries as well. \n<\/p>\n
Below is a sample of such usage. \n<\/p>\n
volatile<\/span> bool<\/span> m_producersEnded = false<\/span>;<\/p>\n<\/span><\/p>\n
const<\/span> int<\/span> COUNT = 10;<\/p>\n<\/span><\/span><\/p>\n
public<\/span> void<\/span> PLinqOverConcurrentStack()<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>\/\/create the producers<\/p>\n<\/span><\/span><\/p>\n
<\/span>Thread<\/span>[] producers = new<\/span> Thread<\/span>[COUNT];<\/p>\n<\/span><\/p>\n
<\/span>for<\/span> (int<\/span> i = 0; i < COUNT; i++)<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>Thread<\/span> currentProducer = new<\/span> Thread<\/span>(new<\/span> ThreadStart<\/span>(delegate<\/span>()<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>for(int<\/span> currentIndex = COUNT; currentIndex > 0; currentIndex–)<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>m_myConcurrentStack.Push(currentIndex.ToString());<\/p>\n<\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/span>}));<\/p>\n<\/span><\/p>\n
<\/span>producers[i] = currentProducer;<\/p>\n<\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/p>\n<\/span><\/p>\n
<\/span>Thread<\/span> PLINQConsumer = new<\/span> Thread<\/span>(new<\/span> ThreadStart<\/span>(delegate<\/span>()<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>while<\/span> (!m_producersEnded)<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>var<\/span> currentValues = from<\/span> data in<\/span> m_myConcurrentStack <\/span><\/p>\n<\/span><\/p>\n
<\/span>where<\/span> data.Contains(“9”<\/span>) select<\/span> data;<\/p>\n<\/span><\/p>\n
<\/span>foreach<\/span> (string<\/span> currentData in<\/span> currentValues)<\/p>\n<\/span><\/p>\n
<\/span>{<\/p>\n<\/span><\/p>\n
<\/span>\/\/consume data <\/p>\n<\/span><\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/span>}<\/p>\n<\/span><\/p>\n
<\/span>}));<\/p>\n<\/span><\/p>\n
<\/p>\n<\/span><\/p>\n
<\/span>\/\/start the consumer<\/p>\n<\/span><\/span><\/p>\n
<\/span>pLinqConsumer.Start();<\/p>\n<\/span><\/p>\n