using System;
using System.Collections;
using System.Collections.Generic;
namespace NewLife.Collections
{
/// <summary>基于lock的安全栈</summary>
/// <remarks>
/// 理论上性能最差,但实际测试发现,似乎比InterlockedStack要好点。
/// 重点是它安全可信。
/// </remarks>
/// <typeparam name="T"></typeparam>
public class LockStack<T> : IStack<T>
{
Stack<T> stack = new Stack<T>();
#region IStack<T> 成员
/// <summary>向栈压入一个对象</summary>
/// <param name="item"></param>
public void Push(T item)
{
lock (stack)
{
stack.Push(item);
}
}
/// <summary>从栈中弹出一个对象</summary>
/// <returns></returns>
public T Pop()
{
lock (stack)
{
return stack.Pop();
}
}
/// <summary>尝试从栈中弹出一个对象</summary>
/// <param name="item"></param>
/// <returns></returns>
public bool TryPop(out T item)
{
item = default(T);
if (stack.Count < 1) return false;
lock (stack)
{
if (stack.Count < 1) return false;
item = stack.Pop();
return true;
}
}
/// <summary>获取栈顶对象,不弹栈</summary>
/// <returns></returns>
public T Peek()
{
lock (stack)
{
return stack.Peek();
}
}
/// <summary>尝试获取栈顶对象,不弹栈</summary>
/// <param name="item"></param>
/// <returns></returns>
public bool TryPeek(out T item)
{
item = default(T);
if (stack.Count < 1) return false;
lock (stack)
{
if (stack.Count < 1) return false;
item = stack.Peek();
return true;
}
}
#endregion
#region IEnumerable<T> 成员
/// <summary>获取枚举器</summary>
/// <returns></returns>
public IEnumerator<T> GetEnumerator() { return stack.GetEnumerator(); }
#endregion
#region IEnumerable 成员
IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
#endregion
#region ICollection 成员
void ICollection.CopyTo(Array array, int index) { (stack as ICollection).CopyTo(array, index); }
int ICollection.Count { get { return stack.Count; } }
bool ICollection.IsSynchronized { get { return true; } }
object ICollection.SyncRoot { get { return (stack as ICollection).SyncRoot; } }
#endregion
#region IDisposable 成员
void IDisposable.Dispose() { stack.Clear(); }
#endregion
}
}
|