C# LockFreeStack类

C# LockFreeStack类

LockFreeStack

SpinWait

/// <summary>
/// SpinWait只有在SMP或多核CPU下才具有使用意义。在单处理器下，旋转非常浪费CPU时间，没有任何意义。
/// 自旋锁特性导致其比较适用一些轻量级，极短时间的多核cpu系统上的锁保护。
/// </summary>
public struct SpinWait
{
public static readonly bool IsSingleProcessor;
private const int yieldFrequency = 4000 ;
private const int yieldOneFrequency = 3 * yieldFrequency;

static SpinWait()
{
IsSingleProcessor = (Environment.ProcessorCount == 1 );
}

private int count;

public int Count
{
get { return count; }
}

public int Spin()
{
int oldCount = count;
// On a single-CPU machine, we ensure our counter is always
// a multiple of �s_yieldFrequency�, so we yield every time.
// Else, we just increment by one.
count += (IsSingleProcessor ? yieldFrequency : 1 );
// If not a multiple of �s_yieldFrequency� spin (w/ backoff).
int countModFrequency = count % yieldFrequency;
if (countModFrequency > 0 )
{
Thread.SpinWait(( int )( 1 + (countModFrequency * 0.05f )));
}
else
{
Thread.Sleep(count <= yieldOneFrequency ? 0 : 1 );
}
return oldCount;
}

public void Yield()
{
Thread.Sleep(count < yieldOneFrequency ? 0 : 1 );
}

public void Reset()
{
count = 0 ;
}
}

public class LockFreeStack : IEnumerable
{
private class SingleLinkedNode
{
public object Value;
public SingleLinkedNode Next;
}

private SingleLinkedNode m_head;
private int count;

public int Count
{
get { return count; }
}

public void Push( object item)
{
SingleLinkedNode node = new SingleLinkedNode();
node.Value = item;
SingleLinkedNode head;
do
{
head = m_head;
node.Next = head;
}
while (m_head != head || Interlocked.CompareExchange( ref m_head, node, head) != head);
Interlocked.Increment( ref count);
}

public object Peek()
{
SingleLinkedNode head = m_head;
if (head == null )
{
throw new InvalidOperationException( " Stack Empty! " );
}
return head.Value;
}

public object Pop()
{
object result;
if (TryPop( out result))
{
return result;
}
throw new InvalidOperationException( " Stack Empty! " );
}

/// <summary>
/// 考虑到在多线程环境中，这里不抛出异常。我们需要人为判断其是否为空，即 !TryPop() or result != null
/// </summary>
/// <returns></returns>
public bool TryPop( out object item)
{
SingleLinkedNode head;
SingleLinkedNode next;
do
{
head = m_head;
if (head == null )
{
item = null ;
return false ;
}
next = m_head.Next;
}
while (Interlocked.CompareExchange( ref m_head, next, head) != head);
Interlocked.Decrement( ref count);
item = head.Value;
return true ;
}

public object SpinPop()
{
SingleLinkedNode head;
SpinWait spin = new SpinWait();
while ( true )
{
SingleLinkedNode next;
do
{
head = m_head;
if (head == null )
{
goto emptySpin;
}
next = head.Next;
}
while (m_head != head || Interlocked.CompareExchange( ref m_head, next, head) != head);
break ;
emptySpin:
spin.Spin();
}
Interlocked.Decrement( ref count);
return head.Value;
}

public bool Contains( object item)
{
SingleLinkedNode head = m_head;
while (m_head != null && head != null )
{
if (head.Value.Equals(item))
{
return true ;
}
head = head.Next;
}
return false ;
}

public void Clear()
{
Interlocked.Exchange( ref m_head, null );
Interlocked.Exchange( ref count, 0 );
}

public IEnumerator GetEnumerator()
{
SingleLinkedNode head = m_head;
while (m_head != null && head != null )
{
yield return head.Value;
head = head.Next;
}
}
}

posted on 2011-03-30 15:56 RockyLOMO 阅读(...) 评论(...) 编辑 收藏