LockCookie Structure

 

Defines the lock that implements single-writer/multiple-reader semantics. This is a value type.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)]
public value struct LockCookie

NameDescription
System_CAPS_pubmethodEquals(LockCookie)

Indicates whether the current instance is equal to the specified LockCookie.

System_CAPS_pubmethodEquals(Object^)

Indicates whether a specified object is a LockCookie and is equal to the current instance.(Overrides ValueType::Equals(Object^).)

System_CAPS_pubmethodGetHashCode()

Returns the hash code for this instance.(Overrides ValueType::GetHashCode().)

System_CAPS_pubmethodGetType()

Gets the Type of the current instance.(Inherited from Object.)

System_CAPS_pubmethodToString()

Returns the fully qualified type name of this instance.(Inherited from ValueType.)

NameDescription
System_CAPS_puboperatorSystem_CAPS_staticEquality(LockCookie, LockCookie)

Indicates whether two LockCookie structures are equal.

System_CAPS_puboperatorSystem_CAPS_staticInequality(LockCookie, LockCookie)

Indicates whether two LockCookie structures are not equal.

The following example shows how to request a reader lock, upgrade the reader lock to a writer lock, and save the LockCookie. It then uses the LockCookie to downgrade to a reader lock again.

This code is part of a larger example provided for the ReaderWriterLock class.

// 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;

// Shows how to request a reader lock, upgrade the
// reader lock to the writer lock, and downgrade to a
// reader lock again.
static void UpgradeDowngrade( int timeOut )
{
   try
   {
      rwl->AcquireReaderLock( timeOut );
      try
      {

         // It is safe for this thread to read from
         // the shared resource.
         Display( String::Format( "reads resource value {0}", resource ) );
         Interlocked::Increment( reads );

         // If it is necessary to write to the resource,
         // you must either release the reader lock and 
         // then request the writer lock, or upgrade the
         // reader lock. Note that upgrading the reader lock
         // puts the thread in the write queue, behind any
         // other threads that might be waiting for the 
         // writer lock.
         try
         {
            LockCookie lc = rwl->UpgradeToWriterLock( timeOut );
            try
            {

               // It is safe for this thread to read or write
               // from the shared resource.
               resource = rnd->Next( 500 );
               Display( String::Format( "writes resource value {0}", resource ) );
               Interlocked::Increment( writes );
            }
            finally
            {

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

         }
         catch ( ApplicationException^ ) 
         {

            // The upgrade request timed out.
            Interlocked::Increment( writerTimeouts );
         }


         // When the lock has been downgraded, it is 
         // still safe to read from the resource.
         Display( String::Format( "reads resource value {0}", resource ) );
         Interlocked::Increment( reads );
      }
      finally
      {

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

   }
   catch ( ApplicationException^ ) 
   {

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

}


.NET Framework
Available since 1.1

This type is thread safe.

Return to top
Show: