C#创建安全的栈(Stack)存储结构

以上是对Stack和线程的相关知识的浅述，现在介绍一下线程安全的Stack：

 /// <summary>
  /// 表示对象的后进先出线程安全集合(栈结构)
  /// </summary>
  /// <typeparam name="T"></typeparam>
  public class TStack<T> : IEnumerable<T>, ICollection
  {
    /// <summary>
    /// 内部堆栈
    /// </summary>
    private readonly Stack<T> _mStack;

    /// <summary>
    /// 锁访问堆栈(用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。)
    /// </summary>
    private readonly ReaderWriterLockSlim _lockStack = new ReaderWriterLockSlim();

    /// <summary>
    /// 仅用于SyncRoot属性
    /// </summary>
    private readonly object _objSyncRoot = new object();

    // Variables
    /// <summary>
    /// 初始化一个新的实例 <see cref="TStack{T}"/> class.
    /// </summary>
    public TStack()
    {
      _mStack = new Stack<T>();
    }

    /// <summary>
    /// 初始化一个新的实例 <see cref="TStack{T}"/> class.
    /// </summary>
    /// <param name="col">
    /// 开始集合
    /// </param>
    public TStack(IEnumerable<T> col)
    {
      _mStack = new Stack<T>(col);
    }

    // Init
    /// <summary>
    /// 获取枚举器
    /// </summary>
    public IEnumerator<T> GetEnumerator()
    {
      Stack<T> localStack = null;

      // 初始化枚举器
      _lockStack.PerformUsingReadLock(() =>
      {
        // 创建一个m_tlist副本
        localStack = new Stack<T>(_mStack);
      });

      // 获取枚举器
      foreach (T item in localStack)
        yield return item;
    }


    /// <summary>
    /// 获取枚举器
    /// </summary>
    IEnumerator IEnumerable.GetEnumerator()
    {
      Stack<T> localStack = null;

      // 初始化枚举器
      _lockStack.PerformUsingReadLock(() =>
      {
        // 创建一个m_TList的副本
        localStack = new Stack<T>(_mStack);
      });

      // 获取枚举器
      foreach (T item in localStack)
        yield return item;
    }


    /// <summary>
    /// 复制到一个数组
    /// </summary>
    /// <param name="array"></param>
    /// <param name="index"></param>
    public void CopyTo(Array array, int index)
    {
      _lockStack.PerformUsingReadLock(() => _mStack.ToArray().CopyTo(array, index));
    }

    /// <summary>
    ///堆栈中的项目数
    /// </summary>
    public int Count
    {
      get
      {
        return _lockStack.PerformUsingReadLock(() => _mStack.Count);
      }
    }

    /// <summary>
    /// 总为真
    /// </summary>
    public bool IsSynchronized
    {
      get { return true; }
    }

    /// <summary>
    ///同步根
    /// </summary>
    public object SyncRoot
    {
      get { return _objSyncRoot; }
    }


    /// <summary>
    ///清除集合
    /// </summary>
    public void Clear()
    {
      _lockStack.PerformUsingWriteLock(() => _mStack.Clear());
    }

    // Clear
    /// <summary>
    ///如果项目在堆栈中，则为true
    /// </summary>
    /// <param name="item"></param>
    /// <returns></returns>
    public bool Contains(T item)
    {
      return _lockStack.PerformUsingReadLock(() => _mStack.Contains(item));
    }

    // 包含
    /// <summary>
    /// 返回堆栈中的顶部项，而不从堆栈中删除它
    /// </summary>
    /// <returns></returns>
    public T Peek()
    {
      return _lockStack.PerformUsingReadLock(() => _mStack.Peek());
    }

    // Peek
    /// <summary>
    ///删除并返回堆栈中的顶部项目
    /// </summary>
    /// <returns></returns>
    public T Pop()
    {
      return _lockStack.PerformUsingWriteLock(() => _mStack.Pop());
    }

    // Pop
    /// <summary>
    /// 将一个项目插入堆栈
    /// </summary>
    /// <param name="item"></param>
    public void Push(T item)
    {
      _lockStack.PerformUsingWriteLock(() => _mStack.Push(item));
    }

    // Push
    /// <summary>
    ///将堆栈转换为数组
    /// </summary>
    /// <returns></returns>
    public T[] ToArray()
    {
      return _lockStack.PerformUsingReadLock(() => _mStack.ToArray());
    }

    // ToArray
    /// <summary>
    /// 将容量设置为堆栈中实际的元素数量
    /// </summary>
    public void TrimExcess()
    {
      _lockStack.PerformUsingWriteLock(() => _mStack.TrimExcess());
    }
  }

								 
 3/4   首页 上一页 1 2 3 4 下一页 尾页