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

   在c#中，用于存储的结构较多，如：datatable，dataset，list，dictionary，stack等结构，各种结构采用的存储的方式存在差异，效率也必然各有优缺点。现在介绍一种后进先出的数据结构。

   谈到存储结构，我们在项目中使用的较多。对于task存储结构，栈与队列是类似的结构，在使用的时候采用不同的方法。c#中栈（stack）是编译期间就分配好的内存空间，因此你的代码中必须就栈的大小有明确的定义；堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小。

    在c#中，栈通常保存着我们代码执行的步骤。c#中的引用类型存储在栈中，在程序运行的时候，每个线程(thread)都会维护一个自己的专属线程堆栈。当一个方法被调用的时候，主线程开始在所属程序集的元数据中，查找被调用方法，然后通过jit即时编译并把结果（一般是本地cpu指令）放在栈顶。cpu通过总线从栈顶取指令，驱动程序以执行下去。

    以上对栈这个数据结构进行了一个简单的介绍，现在看一下c#实现栈结构的底层方法：

  /// <summary>
  /// 初始化 <see cref="t:system.collections.generic.stack`1"/> 类的新实例，该实例为空并且具有默认初始容量。
  /// </summary>
  [__dynamicallyinvokable]
  public stack();
  /// <summary>
  /// 初始化 <see cref="t:system.collections.generic.stack`1"/> 类的新实例，该实例为空，具有指定的初始容量或默认的初始容量（其中较大的一个）。
  /// </summary>
  /// <param name="capacity"><see cref="t:system.collections.generic.stack`1"/> 可包含的初始元素数。</param><exception cref="t:system.argumentoutofrangeexception"><paramref name="capacity"/> is less than zero.</exception>
  [__dynamicallyinvokable]
  public stack(int capacity);
  /// <summary>
  /// 初始化 <see cref="t:system.collections.generic.stack`1"/> 类的新实例，该实例包含从指定集合复制的元素并且具有足够的容量来容纳所复制的元素。
  /// </summary>
  /// <param name="collection">从中复制元素的集合。</param><exception cref="t:system.argumentnullexception"><paramref name="collection"/> is null.</exception>
  [__dynamicallyinvokable]
  public stack(ienumerable<t> collection);

    以上是对stack的部分方法的介绍，由于在操作数据存储的同时，会考虑到线程的安全性。

   进程作为操作系统执行程序的基本单位，拥有应用程序的资源，进程包含线程，进程的资源被线程共享，线程不拥有资源。线程分为前台线程和后台线程，通过thread类新建线程默认为前台线程。当所有前台线程关闭时，所有的后台线程也会被直接终止，不会抛出异常。

    接下来看一下readerwriterlockslim类：

  /// <summary>
 /// 表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。
 /// </summary>
 [__dynamicallyinvokable]
 [hostprotection(securityaction.linkdemand, externalthreading = true, synchronization = true)]
 [hostprotection(securityaction.linkdemand, mayleakonabort = true)]
 public class readerwriterlockslim : idisposable
 {
  /// <summary>
  /// 使用默认属性值初始化 <see cref="t:system.threading.readerwriterlockslim"/> 类的新实例。
  /// </summary>
  [__dynamicallyinvokable]
  public readerwriterlockslim();
  /// <summary>
  /// 在指定锁定递归策略的情况下初始化 <see cref="t:system.threading.readerwriterlockslim"/> 类的新实例。
  /// </summary>
  /// <param name="recursionpolicy">枚举值之一，用于指定锁定递归策略。</param>
  [__dynamicallyinvokable]
  public readerwriterlockslim(lockrecursionpolicy recursionpolicy);
  /// <summary>
  /// 尝试进入读取模式锁定状态。
  /// </summary>
  /// <exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入读取的模式。- 或 -当它已经包含写入锁时，当前线程可能不会获取读的锁定。- 或 -递归数将超出该计数器的容量。此限制是很大的应用程序应永远不会遇到它。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public void enterreadlock();
  /// <summary>
  /// 尝试进入读取模式锁定状态，可以选择超时时间。
  /// </summary>
  /// 
  /// <returns>
  /// 如果调用线程已进入读取模式，则为 true；否则为 false。
  /// </returns>
  /// <param name="timeout">等待的间隔；或为 -1 毫秒，表示无限期等待。</param><exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入该锁。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.argumentoutofrangeexception">值 <paramref name="timeout"/> 为负数，但它不等于-1 毫秒为单位），这是唯一允许的值为负。- 或 -值 <paramref name="timeout"/> 大于 <see cref="f:system.int32.maxvalue"/> 毫秒为单位）。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public bool tryenterreadlock(timespan timeout);
  /// <summary>
  /// 尝试进入读取模式锁定状态，可以选择整数超时时间。
  /// </summary>
  /// 
  /// <returns>
  /// 如果调用线程已进入读取模式，则为 true；否则为 false。
  /// </returns>
  /// <param name="millisecondstimeout">等待的毫秒数，或为 -1 (<see cref="f:system.threading.timeout.infinite"/>)，表示无限期等待。</param><exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入该锁。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.argumentoutofrangeexception">值 <paramref name="millisecondstimeout"/> 为负数，但它不是等于 <see cref="f:system.threading.timeout.infinite"/> (-1)，这是唯一允许的值为负。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public bool tryenterreadlock(int millisecondstimeout);
  /// <summary>
  /// 尝试进入写入模式锁定状态。
  /// </summary>
  /// <exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已在任何模式下进入该锁。- 或 -当前线程已进入读取的模式，因此尝试进入锁定状态写模式，则会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public void enterwritelock();
  /// <summary>
  /// 尝试进入写入模式锁定状态，可以选择超时时间。
  /// </summary>
  /// 
  /// <returns>
  /// 如果调用线程已进入写入模式，则为 true；否则为 false。
  /// </returns>
  /// <param name="timeout">等待的间隔；或为 -1 毫秒，表示无限期等待。</param><exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入写入模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.argumentoutofrangeexception">值 <paramref name="timeout"/> 为负数，但它不等于-1 毫秒为单位），这是唯一允许的值为负。- 或 -值 <paramref name="timeout"/> 大于 <see cref="f:system.int32.maxvalue"/> 毫秒为单位）。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public bool tryenterwritelock(timespan timeout);
  /// <summary>
  /// 尝试进入写入模式锁定状态，可以选择超时时间。
  /// </summary>
  /// 
  /// <returns>
  /// 如果调用线程已进入写入模式，则为 true；否则为 false。
  /// </returns>
  /// <param name="millisecondstimeout">等待的毫秒数，或为 -1 (<see cref="f:system.threading.timeout.infinite"/>)，表示无限期等待。</param><exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入写入模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.argumentoutofrangeexception">值 <paramref name="millisecondstimeout"/> 为负数，但它不是等于 <see cref="f:system.threading.timeout.infinite"/> (-1)，这是唯一允许的值为负。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public bool tryenterwritelock(int millisecondstimeout);
  /// <summary>
  /// 尝试进入可升级模式锁定状态。
  /// </summary>
  /// <exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已在任何模式下进入该锁。- 或 -当前线程已进入读取的模式，因此尝试进入可升级模式将有死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public void enterupgradeablereadlock();
  /// <summary>
  /// 尝试进入可升级模式锁定状态，可以选择超时时间。
  /// </summary>
  /// 
  /// <returns>
  /// 如果调用线程已进入可升级模式，则为 true；否则为 false。
  /// </returns>
  /// <param name="timeout">等待的间隔；或为 -1 毫秒，表示无限期等待。</param><exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入可升级模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.argumentoutofrangeexception">值 <paramref name="timeout"/> 为负数，但它不等于-1 毫秒为单位），这是唯一允许的值为负。- 或 -值 <paramref name="timeout"/> 大于 <see cref="f:system.int32.maxvalue"/> 毫秒为单位）。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public bool tryenterupgradeablereadlock(timespan timeout);
  /// <summary>
  /// 尝试进入可升级模式锁定状态，可以选择超时时间。
  /// </summary>
  /// 
  /// <returns>
  /// 如果调用线程已进入可升级模式，则为 true；否则为 false。
  /// </returns>
  /// <param name="millisecondstimeout">等待的毫秒数，或为 -1 (<see cref="f:system.threading.timeout.infinite"/>)，表示无限期等待。</param><exception cref="t:system.threading.lockrecursionexception"><see cref="p:system.threading.readerwriterlockslim.recursionpolicy"/> 属性是 <see cref="f:system.threading.lockrecursionpolicy.norecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入可升级模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="t:system.argumentoutofrangeexception">值 <paramref name="millisecondstimeout"/> 为负数，但它不是等于 <see cref="f:system.threading.timeout.infinite"/> (-1)，这是唯一允许的值为负。</exception><exception cref="t:system.objectdisposedexception"><see cref="t:system.threading.readerwriterlockslim"/> 对象已被释放。</exception>
  [__dynamicallyinvokable]
  public bool tryenterupgradeablereadlock(int millisecondstimeout);
  /// <summary>
  /// 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。
  /// </summary>
  /// <exception cref="t:system.threading.synchronizationlockexception">在读取模式中，当前线程不已进入该锁。</exception>
  [__dynamicallyinvokable]
  public void exitreadlock();
  /// <summary>
  /// 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。
  /// </summary>
  /// <exception cref="t:system.threading.synchronizationlockexception">当前线程不已进入写入模式的锁定。</exception>
  [__dynamicallyinvokable]
  public void exitwritelock();
  /// <summary>
  /// 减少可升级模式的递归计数，并在生成的计数为 0（零）时退出可升级模式。
  /// </summary>
  /// <exception cref="t:system.threading.synchronizationlockexception">当前线程不已进入可升级模式的锁定。</exception>
  [__dynamicallyinvokable]
  public void exitupgradeablereadlock();
  /// <summary>
  /// 释放 <see cref="t:system.threading.readerwriterlockslim"/> 类的当前实例所使用的所有资源。
  /// </summary>
  /// <exception cref="t:system.threading.synchronizationlockexception"><see cref="p:system.threading.readerwriterlockslim.waitingreadcount"/> 是大于零。- 或 -<see cref="p:system.threading.readerwriterlockslim.waitingupgradecount"/> 是大于零。- 或 -<see cref="p:system.threading.readerwriterlockslim.waitingwritecount"/> 是大于零。</exception><filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public void dispose();
  /// <summary>
  /// 获取一个值，该值指示当前线程是否已进入读取模式的锁定状态。
  /// </summary>
  /// 
  /// <returns>
  /// 如果当前线程已进入读取模式，则为 true；否则为 false。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public bool isreadlockheld { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取一个值，该值指示当前线程是否已进入可升级模式的锁定状态。
  /// </summary>
  /// 
  /// <returns>
  /// 如果当前线程已进入可升级模式，则为 true；否则为 false。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public bool isupgradeablereadlockheld { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取一个值，该值指示当前线程是否已进入写入模式的锁定状态。
  /// </summary>
  /// 
  /// <returns>
  /// 如果当前线程已进入写入模式，则为 true；否则为 false。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public bool iswritelockheld { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取一个值，该值指示当前 <see cref="t:system.threading.readerwriterlockslim"/> 对象的递归策略。
  /// </summary>
  /// 
  /// <returns>
  /// 枚举值之一，用于指定锁定递归策略。
  /// </returns>
  [__dynamicallyinvokable]
  public lockrecursionpolicy recursionpolicy { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取已进入读取模式锁定状态的独有线程的总数。
  /// </summary>
  /// 
  /// <returns>
  /// 已进入读取模式锁定状态的独有线程的数量。
  /// </returns>
  [__dynamicallyinvokable]
  public int currentreadcount { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取当前线程进入读取模式锁定状态的次数，用于指示递归。
  /// </summary>
  /// 
  /// <returns>
  /// 如果当前线程未进入读取模式，则为 0（零）；如果线程已进入读取模式但却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入锁定模式 n - 1 次，则为 n。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public int recursivereadcount { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取当前线程进入可升级模式锁定状态的次数，用于指示递归。
  /// </summary>
  /// 
  /// <returns>
  /// 如果当前线程没有进入可升级模式，则为 0；如果线程已进入可升级模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入可升级模式 n - 1 次，则为 n。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public int recursiveupgradecount { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取当前线程进入写入模式锁定状态的次数，用于指示递归。
  /// </summary>
  /// 
  /// <returns>
  /// 如果当前线程没有进入写入模式，则为 0；如果线程已进入写入模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入写入模式 n - 1 次，则为 n。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public int recursivewritecount { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取等待进入读取模式锁定状态的线程总数。
  /// </summary>
  /// 
  /// <returns>
  /// 等待进入读取模式的线程总数。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public int waitingreadcount { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取等待进入可升级模式锁定状态的线程总数。
  /// </summary>
  /// 
  /// <returns>
  /// 等待进入可升级模式的线程总数。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public int waitingupgradecount { [__dynamicallyinvokable] get; }
  /// <summary>
  /// 获取等待进入写入模式锁定状态的线程总数。
  /// </summary>
  /// 
  /// <returns>
  /// 等待进入写入模式的线程总数。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__dynamicallyinvokable]
  public int waitingwritecount { [__dynamicallyinvokable] get; }
 }

以上是对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());
    }
  }

    以上的操作方法继承了ienumerable<t>, icollection两个接口。有兴趣的，可以对ienumerable<t>, icollection两个接口进行细致的了解。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。