ReaderWriterLock.RestoreLock(LockCookie) 方法

定義

命名空間:

System.Threading

組件:

System.Threading.dll

來源:

ReaderWriterLock.cs

將執行緒的鎖定狀態還原到呼叫 ReleaseLock() 之前的狀態。

public:
 void RestoreLock(System::Threading::LockCookie % lockCookie);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public void RestoreLock (ref System.Threading.LockCookie lockCookie);

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
member this.RestoreLock : LockCookie -> unit

Public Sub RestoreLock (ByRef lockCookie As LockCookie)

參數

lockCookie

LockCookie

LockCookie 所傳回的 ReleaseLock()。

屬性

UnsupportedOSPlatformAttribute

例外狀況

NullReferenceException

lockCookie 的位址為 null 指標。

範例

下列程式碼範例示範如何使用 ReleaseLock 方法來釋放鎖定，不論執行緒取得多少次，以及如何稍後還原鎖定的狀態。

此程式碼是類別所提供較大範例的 ReaderWriterLock 一部分。

// The complete code is located in the ReaderWriterLock
// class topic.
using namespace System;
using namespace System::Threading;
public ref class Test
{
public:

   // Declaring the ReaderWriterLock at the class level
   // makes it visible to all threads.
   static ReaderWriterLock^ rwl = gcnew ReaderWriterLock;

   // For this example, the shared resource protected by the
   // ReaderWriterLock is just an integer.
   static int resource = 0;

// The complete code is located in the ReaderWriterLock class topic.
using System;
using System.Threading;

public class Example
{
   static ReaderWriterLock rwl = new ReaderWriterLock();
   // Define the shared resource protected by the ReaderWriterLock.
   static int resource = 0;

' The complete code is located in the ReaderWriterLock class topic.
Imports System.Threading

Public Module Example
   Private rwl As New ReaderWriterLock()
   ' Define the shared resource protected by the ReaderWriterLock.
   Private resource As Integer = 0

// Shows how to release all locks and later restore
// the lock state. Shows how to use sequence numbers
// to determine whether another thread has obtained
// a writer lock since this thread last accessed the
// resource.
static void ReleaseRestore( Random^ rnd, int timeOut )
{
   int lastWriter;
   try
   {
      rwl->AcquireReaderLock( timeOut );
      try
      {

         // It is safe for this thread to read from
         // the shared resource. Cache the value. (You
         // might do this if reading the resource is
         // an expensive operation.)
         int resourceValue = resource;
         Display( String::Format( "reads resource value {0}", resourceValue ) );
         Interlocked::Increment( reads );

         // Save the current writer sequence number.
         lastWriter = rwl->WriterSeqNum;

         // Release the lock, and save a cookie so the
         // lock can be restored later.
         LockCookie lc = rwl->ReleaseLock();

         // Wait for a random interval (up to a
         // quarter of a second), and then restore
         // the previous state of the lock. Note that
         // there is no timeout on the Restore method.
         Thread::Sleep( rnd->Next( 250 ) );
         rwl->RestoreLock( lc );

         // Check whether other threads obtained the
         // writer lock in the interval. If not, then
         // the cached value of the resource is still
         // valid.
         if ( rwl->AnyWritersSince( lastWriter ) )
         {
            resourceValue = resource;
            Interlocked::Increment( reads );
            Display( String::Format( "resource has changed {0}", resourceValue ) );
         }
         else
         {
            Display( String::Format( "resource has not changed {0}", resourceValue ) );
         }
      }
      finally
      {

         // Ensure that the lock is released.
         rwl->ReleaseReaderLock();
      }

   }
   catch ( ApplicationException^ )
   {

      // The reader lock request timed out.
      Interlocked::Increment( readerTimeouts );
   }

}

// Release all locks and later restores the lock state.
// Uses sequence numbers to determine whether another thread has
// obtained a writer lock since this thread last accessed the resource.
static void ReleaseRestore(Random rnd, int timeOut)
{
   int lastWriter;

   try {
      rwl.AcquireReaderLock(timeOut);
      try {
         // It's safe for this thread to read from the shared resource,
         // so read and cache the resource value.
         int resourceValue = resource;     // Cache the resource value.
         Display("reads resource value " + resourceValue);
         Interlocked.Increment(ref reads);

         // Save the current writer sequence number.
         lastWriter = rwl.WriterSeqNum;

         // Release the lock and save a cookie so the lock can be restored later.
         LockCookie lc = rwl.ReleaseLock();

         // Wait for a random interval and then restore the previous state of the lock.
         Thread.Sleep(rnd.Next(250));
         rwl.RestoreLock(ref lc);

         // Check whether other threads obtained the writer lock in the interval.
         // If not, then the cached value of the resource is still valid.
         if (rwl.AnyWritersSince(lastWriter)) {
            resourceValue = resource;
            Interlocked.Increment(ref reads);
            Display("resource has changed " + resourceValue);
         }
         else {
            Display("resource has not changed " + resourceValue);
         }
      }
      finally {
         // Ensure that the lock is released.
         rwl.ReleaseReaderLock();
      }
   }
   catch (ApplicationException) {
      // The reader lock request timed out.
      Interlocked.Increment(ref readerTimeouts);
   }
}

' Release all locks and later restores the lock state.
' Uses sequence numbers to determine whether another thread has
' obtained a writer lock since this thread last accessed the resource.
Sub ReleaseRestore(rnd As Random ,timeOut As Integer)
   Dim lastWriter As Integer
   
   Try
      rwl.AcquireReaderLock(timeOut)
      Try
         ' It's safe for this thread to read from the shared resource,
         ' so read and cache the resource value.
         Dim resourceValue As Integer = resource
         Display("reads resource value " & resourceValue)
         Interlocked.Increment(reads)
         
         ' Save the current writer sequence number.
         lastWriter = rwl.WriterSeqNum
         
         ' Release the lock and save a cookie so the lock can be restored later.
         Dim lc As LockCookie = rwl.ReleaseLock()
         
         ' Wait for a random interval and then restore the previous state of the lock.
         Thread.Sleep(rnd.Next(250))
         rwl.RestoreLock(lc)
        
         ' Check whether other threads obtained the writer lock in the interval.
         ' If not, then the cached value of the resource is still valid.
         If rwl.AnyWritersSince(lastWriter) Then
            resourceValue = resource
            Interlocked.Increment(reads)
            Display("resource has changed " & resourceValue)
         Else
            Display("resource has not changed " & resourceValue)
         End If
      Finally
         ' Ensure that the lock is released.
         rwl.ReleaseReaderLock()
      End Try
   Catch ex As ApplicationException
      ' The reader lock request timed out.
      Interlocked.Increment(readerTimeouts)
   End Try
End Sub

};

}

End Module

備註

還原 RestoreLock 的狀態包括遞迴鎖定計數。

如果執行緒嘗試在另一個執行緒取得寫入器鎖定之後還原讀取器鎖定，或嘗試在另一個執行緒取得讀取器鎖定或寫入器鎖定之後還原寫入器鎖定，則執行緒會封鎖。 因為 RestoreLock 不接受逾時，您應該小心避免可能的死結。

警告

呼叫 RestoreLock 之前，請確定您已釋放自 呼叫 ReleaseLock 之後取得的所有鎖定。 例如，如果執行緒取得讀取器鎖定，則執行緒死結，然後嘗試還原先前的寫入器鎖定。 使用 IsReaderLockHeld 和 IsWriterLockHeld 來偵測這類額外的鎖定。

請勿使用從 UpgradeToWriterLock 傳回的 LockCookie 。

另請參閱

• Managed 執行緒處理
• ReaderWriterLock