欧美大屁股bbbbxxxx,狼人大香伊蕉国产www亚洲,男ji大巴进入女人的视频小说,男人把ji大巴放进女人免费视频,免费情侣作爱视频

歡迎來到入門教程網(wǎng)！

C#教程

當(dāng)前位置：主頁 > 軟件編程 > C#教程 >

C#創(chuàng)建安全的棧(Stack)存儲結(jié)構(gòu)

來源：本站原創(chuàng)|時間：2020-01-10|欄目：C#教程|點(diǎn)擊： 次

   在C#中，用于存儲的結(jié)構(gòu)較多，如：DataTable，DataSet，List，Dictionary，Stack等結(jié)構(gòu)，各種結(jié)構(gòu)采用的存儲的方式存在差異，效率也必然各有優(yōu)缺點(diǎn)?，F(xiàn)在介紹一種后進(jìn)先出的數(shù)據(jù)結(jié)構(gòu)。

   談到存儲結(jié)構(gòu)，我們在項目中使用的較多。對于Task存儲結(jié)構(gòu)，棧與隊列是類似的結(jié)構(gòu)，在使用的時候采用不同的方法。C#中棧（Stack）是編譯期間就分配好的內(nèi)存空間，因此你的代碼中必須就棧的大小有明確的定義；堆是程序運(yùn)行期間動態(tài)分配的內(nèi)存空間，你可以根據(jù)程序的運(yùn)行情況確定要分配的堆內(nèi)存的大小。

    在C#中，棧通常保存著我們代碼執(zhí)行的步驟。C#中的引用類型存儲在棧中，在程序運(yùn)行的時候，每個線程(Thread)都會維護(hù)一個自己的專屬線程堆棧。當(dāng)一個方法被調(diào)用的時候，主線程開始在所屬程序集的元數(shù)據(jù)中，查找被調(diào)用方法，然后通過JIT即時編譯并把結(jié)果（一般是本地CPU指令）放在棧頂。CPU通過總線從棧頂取指令，驅(qū)動程序以執(zhí)行下去。

    以上對棧這個數(shù)據(jù)結(jié)構(gòu)進(jìn)行了一個簡單的介紹，現(xiàn)在看一下C#實現(xiàn)棧結(jié)構(gòu)的底層方法：

  /// <summary>
  /// 初始化 <see cref="T:System.Collections.Generic.Stack`1"/> 類的新實例，該實例為空并且具有默認(rèn)初始容量。
  /// </summary>
  [__DynamicallyInvokable]
  public Stack();
  /// <summary>
  /// 初始化 <see cref="T:System.Collections.Generic.Stack`1"/> 類的新實例，該實例為空，具有指定的初始容量或默認(rèn)的初始容量（其中較大的一個）。
  /// </summary>
  /// <param name="capacity"><see cref="T:System.Collections.Generic.Stack`1"/> 可包含的初始元素數(shù)。</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"/> 類的新實例，該實例包含從指定集合復(fù)制的元素并且具有足夠的容量來容納所復(fù)制的元素。
  /// </summary>
  /// <param name="collection">從中復(fù)制元素的集合。</param><exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
  [__DynamicallyInvokable]
  public Stack(IEnumerable<T> collection);

    以上是對stack的部分方法的介紹，由于在操作數(shù)據(jù)存儲的同時，會考慮到線程的安全性。

   進(jìn)程作為操作系統(tǒng)執(zhí)行程序的基本單位，擁有應(yīng)用程序的資源，進(jìn)程包含線程，進(jìn)程的資源被線程共享，線程不擁有資源。線程分為前臺線程和后臺線程，通過Thread類新建線程默認(rèn)為前臺線程。當(dāng)所有前臺線程關(guān)閉時，所有的后臺線程也會被直接終止，不會拋出異常。

    接下來看一下ReaderWriterLockSlim類：

  /// <summary>
 /// 表示用于管理資源訪問的鎖定狀態(tài)，可實現(xiàn)多線程讀取或進(jìn)行獨(dú)占式寫入訪問。
 /// </summary>
 [__DynamicallyInvokable]
 [HostProtection(SecurityAction.LinkDemand, ExternalThreading = true, Synchronization = true)]
 [HostProtection(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
 public class ReaderWriterLockSlim : IDisposable
 {
  /// <summary>
  /// 使用默認(rèn)屬性值初始化 <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>
  /// 嘗試進(jìn)入讀取模式鎖定狀態(tài)。
  /// </summary>
  /// <exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 屬性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和當(dāng)前的線程已進(jìn)入讀取的模式。- 或 -當(dāng)它已經(jīng)包含寫入鎖時，當(dāng)前線程可能不會獲取讀的鎖定。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。此限制是很大的應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象已被釋放。</exception>
  [__DynamicallyInvokable]
  public void EnterReadLock();
  /// <summary>
  /// 嘗試進(jìn)入讀取模式鎖定狀態(tài)，可以選擇超時時間。
  /// </summary>
  /// 
  /// <returns>
  /// 如果調(diào)用線程已進(jìn)入讀取模式，則為 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"/> 和當(dāng)前的線程已進(jìn)入該鎖。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="timeout"/> 為負(fù)數(shù)，但它不等于-1 毫秒為單位），這是唯一允許的值為負(fù)。- 或 -值 <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>
  /// 嘗試進(jìn)入讀取模式鎖定狀態(tài)，可以選擇整數(shù)超時時間。
  /// </summary>
  /// 
  /// <returns>
  /// 如果調(diào)用線程已進(jìn)入讀取模式，則為 true；否則為 false。
  /// </returns>
  /// <param name="millisecondsTimeout">等待的毫秒數(shù)，或為 -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"/> 和當(dāng)前的線程已進(jìn)入該鎖。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="millisecondsTimeout"/> 為負(fù)數(shù)，但它不是等于 <see cref="F:System.Threading.Timeout.Infinite"/> (-1)，這是唯一允許的值為負(fù)。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象已被釋放。</exception>
  [__DynamicallyInvokable]
  public bool TryEnterReadLock(int millisecondsTimeout);
  /// <summary>
  /// 嘗試進(jìn)入寫入模式鎖定狀態(tài)。
  /// </summary>
  /// <exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 屬性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和當(dāng)前的線程已在任何模式下進(jìn)入該鎖。- 或 -當(dāng)前線程已進(jìn)入讀取的模式，因此嘗試進(jìn)入鎖定狀態(tài)寫模式，則會創(chuàng)建導(dǎo)致死鎖的可能性。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象已被釋放。</exception>
  [__DynamicallyInvokable]
  public void EnterWriteLock();
  /// <summary>
  /// 嘗試進(jìn)入寫入模式鎖定狀態(tài)，可以選擇超時時間。
  /// </summary>
  /// 
  /// <returns>
  /// 如果調(diào)用線程已進(jìn)入寫入模式，則為 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"/> 和當(dāng)前的線程已進(jìn)入該鎖。- 或 -當(dāng)前線程最初在讀取模式中，輸入該鎖，因此嘗試進(jìn)入寫入模式會創(chuàng)建導(dǎo)致死鎖的可能性。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="timeout"/> 為負(fù)數(shù)，但它不等于-1 毫秒為單位），這是唯一允許的值為負(fù)。- 或 -值 <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>
  /// 嘗試進(jìn)入寫入模式鎖定狀態(tài)，可以選擇超時時間。
  /// </summary>
  /// 
  /// <returns>
  /// 如果調(diào)用線程已進(jìn)入寫入模式，則為 true；否則為 false。
  /// </returns>
  /// <param name="millisecondsTimeout">等待的毫秒數(shù)，或為 -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"/> 和當(dāng)前的線程已進(jìn)入該鎖。- 或 -當(dāng)前線程最初在讀取模式中，輸入該鎖，因此嘗試進(jìn)入寫入模式會創(chuàng)建導(dǎo)致死鎖的可能性。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="millisecondsTimeout"/> 為負(fù)數(shù)，但它不是等于 <see cref="F:System.Threading.Timeout.Infinite"/> (-1)，這是唯一允許的值為負(fù)。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象已被釋放。</exception>
  [__DynamicallyInvokable]
  public bool TryEnterWriteLock(int millisecondsTimeout);
  /// <summary>
  /// 嘗試進(jìn)入可升級模式鎖定狀態(tài)。
  /// </summary>
  /// <exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 屬性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和當(dāng)前的線程已在任何模式下進(jìn)入該鎖。- 或 -當(dāng)前線程已進(jìn)入讀取的模式，因此嘗試進(jìn)入可升級模式將有死鎖的可能性。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象已被釋放。</exception>
  [__DynamicallyInvokable]
  public void EnterUpgradeableReadLock();
  /// <summary>
  /// 嘗試進(jìn)入可升級模式鎖定狀態(tài)，可以選擇超時時間。
  /// </summary>
  /// 
  /// <returns>
  /// 如果調(diào)用線程已進(jìn)入可升級模式，則為 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"/> 和當(dāng)前的線程已進(jìn)入該鎖。- 或 -當(dāng)前線程最初在讀取模式中，輸入該鎖，因此嘗試進(jìn)入可升級模式會創(chuàng)建導(dǎo)致死鎖的可能性。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="timeout"/> 為負(fù)數(shù)，但它不等于-1 毫秒為單位），這是唯一允許的值為負(fù)。- 或 -值 <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>
  /// 嘗試進(jìn)入可升級模式鎖定狀態(tài)，可以選擇超時時間。
  /// </summary>
  /// 
  /// <returns>
  /// 如果調(diào)用線程已進(jìn)入可升級模式，則為 true；否則為 false。
  /// </returns>
  /// <param name="millisecondsTimeout">等待的毫秒數(shù)，或為 -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"/> 和當(dāng)前的線程已進(jìn)入該鎖。- 或 -當(dāng)前線程最初在讀取模式中，輸入該鎖，因此嘗試進(jìn)入可升級模式會創(chuàng)建導(dǎo)致死鎖的可能性。- 或 -遞歸數(shù)將超出該計數(shù)器的容量。限制為應(yīng)用程序應(yīng)永遠(yuǎn)不會遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="millisecondsTimeout"/> 為負(fù)數(shù)，但它不是等于 <see cref="F:System.Threading.Timeout.Infinite"/> (-1)，這是唯一允許的值為負(fù)。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象已被釋放。</exception>
  [__DynamicallyInvokable]
  public bool TryEnterUpgradeableReadLock(int millisecondsTimeout);
  /// <summary>
  /// 減少讀取模式的遞歸計數(shù)，并在生成的計數(shù)為 0（零）時退出讀取模式。
  /// </summary>
  /// <exception cref="T:System.Threading.SynchronizationLockException">在讀取模式中，當(dāng)前線程不已進(jìn)入該鎖。</exception>
  [__DynamicallyInvokable]
  public void ExitReadLock();
  /// <summary>
  /// 減少寫入模式的遞歸計數(shù)，并在生成的計數(shù)為 0（零）時退出寫入模式。
  /// </summary>
  /// <exception cref="T:System.Threading.SynchronizationLockException">當(dāng)前線程不已進(jìn)入寫入模式的鎖定。</exception>
  [__DynamicallyInvokable]
  public void ExitWriteLock();
  /// <summary>
  /// 減少可升級模式的遞歸計數(shù)，并在生成的計數(shù)為 0（零）時退出可升級模式。
  /// </summary>
  /// <exception cref="T:System.Threading.SynchronizationLockException">當(dāng)前線程不已進(jìn)入可升級模式的鎖定。</exception>
  [__DynamicallyInvokable]
  public void ExitUpgradeableReadLock();
  /// <summary>
  /// 釋放 <see cref="T:System.Threading.ReaderWriterLockSlim"/> 類的當(dāng)前實例所使用的所有資源。
  /// </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>
  /// 獲取一個值，該值指示當(dāng)前線程是否已進(jìn)入讀取模式的鎖定狀態(tài)。
  /// </summary>
  /// 
  /// <returns>
  /// 如果當(dāng)前線程已進(jìn)入讀取模式，則為 true；否則為 false。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public bool IsReadLockHeld { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取一個值，該值指示當(dāng)前線程是否已進(jìn)入可升級模式的鎖定狀態(tài)。
  /// </summary>
  /// 
  /// <returns>
  /// 如果當(dāng)前線程已進(jìn)入可升級模式，則為 true；否則為 false。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public bool IsUpgradeableReadLockHeld { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取一個值，該值指示當(dāng)前線程是否已進(jìn)入寫入模式的鎖定狀態(tài)。
  /// </summary>
  /// 
  /// <returns>
  /// 如果當(dāng)前線程已進(jìn)入寫入模式，則為 true；否則為 false。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public bool IsWriteLockHeld { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取一個值，該值指示當(dāng)前 <see cref="T:System.Threading.ReaderWriterLockSlim"/> 對象的遞歸策略。
  /// </summary>
  /// 
  /// <returns>
  /// 枚舉值之一，用于指定鎖定遞歸策略。
  /// </returns>
  [__DynamicallyInvokable]
  public LockRecursionPolicy RecursionPolicy { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取已進(jìn)入讀取模式鎖定狀態(tài)的獨(dú)有線程的總數(shù)。
  /// </summary>
  /// 
  /// <returns>
  /// 已進(jìn)入讀取模式鎖定狀態(tài)的獨(dú)有線程的數(shù)量。
  /// </returns>
  [__DynamicallyInvokable]
  public int CurrentReadCount { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取當(dāng)前線程進(jìn)入讀取模式鎖定狀態(tài)的次數(shù)，用于指示遞歸。
  /// </summary>
  /// 
  /// <returns>
  /// 如果當(dāng)前線程未進(jìn)入讀取模式，則為 0（零）；如果線程已進(jìn)入讀取模式但卻不是以遞歸方式進(jìn)入的，則為 1；或者如果線程已經(jīng)以遞歸方式進(jìn)入鎖定模式 n - 1 次，則為 n。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public int RecursiveReadCount { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取當(dāng)前線程進(jìn)入可升級模式鎖定狀態(tài)的次數(shù)，用于指示遞歸。
  /// </summary>
  /// 
  /// <returns>
  /// 如果當(dāng)前線程沒有進(jìn)入可升級模式，則為 0；如果線程已進(jìn)入可升級模式卻不是以遞歸方式進(jìn)入的，則為 1；或者如果線程已經(jīng)以遞歸方式進(jìn)入可升級模式 n - 1 次，則為 n。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public int RecursiveUpgradeCount { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取當(dāng)前線程進(jìn)入寫入模式鎖定狀態(tài)的次數(shù)，用于指示遞歸。
  /// </summary>
  /// 
  /// <returns>
  /// 如果當(dāng)前線程沒有進(jìn)入寫入模式，則為 0；如果線程已進(jìn)入寫入模式卻不是以遞歸方式進(jìn)入的，則為 1；或者如果線程已經(jīng)以遞歸方式進(jìn)入寫入模式 n - 1 次，則為 n。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public int RecursiveWriteCount { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取等待進(jìn)入讀取模式鎖定狀態(tài)的線程總數(shù)。
  /// </summary>
  /// 
  /// <returns>
  /// 等待進(jìn)入讀取模式的線程總數(shù)。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public int WaitingReadCount { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取等待進(jìn)入可升級模式鎖定狀態(tài)的線程總數(shù)。
  /// </summary>
  /// 
  /// <returns>
  /// 等待進(jìn)入可升級模式的線程總數(shù)。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public int WaitingUpgradeCount { [__DynamicallyInvokable] get; }
  /// <summary>
  /// 獲取等待進(jìn)入寫入模式鎖定狀態(tài)的線程總數(shù)。
  /// </summary>
  /// 
  /// <returns>
  /// 等待進(jìn)入寫入模式的線程總數(shù)。
  /// </returns>
  /// <filterpriority>2</filterpriority>
  [__DynamicallyInvokable]
  public int WaitingWriteCount { [__DynamicallyInvokable] get; }
 }

以上是對Stack和線程的相關(guān)知識的淺述，現(xiàn)在介紹一下線程安全的Stack：

 /// <summary>
  /// 表示對象的后進(jìn)先出線程安全集合(棧結(jié)構(gòu))
  /// </summary>
  /// <typeparam name="T"></typeparam>
  public class TStack<T> : IEnumerable<T>, ICollection
  {
    /// <summary>
    /// 內(nèi)部堆棧
    /// </summary>
    private readonly Stack<T> _mStack;

    /// <summary>
    /// 鎖訪問堆棧(用于管理資源訪問的鎖定狀態(tài)，可實現(xiàn)多線程讀取或進(jìn)行獨(dú)占式寫入訪問。)
    /// </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(() =>
      {
        // 創(chuàng)建一個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(() =>
      {
        // 創(chuàng)建一個m_TList的副本
        localStack = new Stack<T>(_mStack);
      });

      // 獲取枚舉器
      foreach (T item in localStack)
        yield return item;
    }


    /// <summary>
    /// 復(fù)制到一個數(shù)組
    /// </summary>
    /// <param name="array"></param>
    /// <param name="index"></param>
    public void CopyTo(Array array, int index)
    {
      _lockStack.PerformUsingReadLock(() => _mStack.ToArray().CopyTo(array, index));
    }

    /// <summary>
    ///堆棧中的項目數(shù)
    /// </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>
    ///將堆棧轉(zhuǎn)換為數(shù)組
    /// </summary>
    /// <returns></returns>
    public T[] ToArray()
    {
      return _lockStack.PerformUsingReadLock(() => _mStack.ToArray());
    }

    // ToArray
    /// <summary>
    /// 將容量設(shè)置為堆棧中實際的元素數(shù)量
    /// </summary>
    public void TrimExcess()
    {
      _lockStack.PerformUsingWriteLock(() => _mStack.TrimExcess());
    }
  }

    以上的操作方法繼承了IEnumerable<T>, ICollection兩個接口。有興趣的，可以對IEnumerable<T>, ICollection兩個接口進(jìn)行細(xì)致的了解。

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持我們。

上一篇：C#如何檢測操作系統(tǒng)版本

欄    目：C#教程

下一篇：WPF換膚設(shè)計原理淺析

本文標(biāo)題：C#創(chuàng)建安全的棧(Stack)存儲結(jié)構(gòu)

本文地址：http://mengdiqiu.com.cn/a1/C_jiaocheng/6227.html

網(wǎng)頁制作CMS教程網(wǎng)絡(luò)編程軟件編程腳本語言數(shù)據(jù)庫服務(wù)器

如果侵犯了您的權(quán)利，請與我們聯(lián)系，我們將在24小時內(nèi)進(jìn)行處理、任何非本站因素導(dǎo)致的法律后果，本站均不負(fù)任何責(zé)任。

聯(lián)系QQ：835971066 | 郵箱：835971066#qq.com(#換成@)

Copyright © 2002-2020 腳本教程網(wǎng) 版權(quán)所有