UpgradeToWriterLock Method

ReaderWriterLock.UpgradeToWriterLock Method

Upgrades a reader lock to the writer lock.

Overload List

Upgrades a reader lock to the writer lock, using an Int32 value for the time-out.

[Visual Basic] Overloads Public Function UpgradeToWriterLock(Integer) As LockCookie
[C#] public LockCookie UpgradeToWriterLock(int);
[C++] public: LockCookie UpgradeToWriterLock(int);
[JScript] public function UpgradeToWriterLock(int) : LockCookie;

Upgrades a reader lock to the writer lock, using a TimeSpan value for the time-out.

[Visual Basic] Overloads Public Function UpgradeToWriterLock(TimeSpan) As LockCookie
[C#] public LockCookie UpgradeToWriterLock(TimeSpan);
[C++] public: LockCookie UpgradeToWriterLock(TimeSpan);
[JScript] public function UpgradeToWriterLock(TimeSpan) : LockCookie;

Example

[Visual Basic, C#, C++] Note   This example shows how to use one of the overloaded versions of UpgradeToWriterLock. For other examples that might be available, see the individual overload topics.
[Visual Basic] 

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

Public Class Test
    ' Declaring the ReaderWriterLock at the class level
    ' makes it visible to all threads.
    Private Shared rwl As New ReaderWriterLock()
    ' For this example, the shared resource protected by the
    ' ReaderWriterLock is just an integer.
    Private Shared resource As Integer = 0
    . . . 
    ' Shows how to request a reader lock, upgrade the
    ' reader lock to the writer lock, and downgrade to a
    ' reader lock again.
    Shared Sub UpgradeDowngrade(timeOut As Integer)
        Try
            rwl.AcquireReaderLock(timeOut)
            Try
                ' It is safe for this thread to read from
                ' the shared resource.
                Display("reads resource value " & 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
                    Dim lc As LockCookie = rwl.UpgradeToWriterLock(timeOut)
                    Try
                        ' It is safe for this thread to read or write
                        ' from the shared resource.
                        resource = rnd.Next(500)
                        Display("writes resource value " & resource)
                        Interlocked.Increment(writes)
                    Finally
                        ' Ensure that the lock is released.
                        rwl.DowngradeFromWriterLock(lc)
                    End Try
                Catch ex As ApplicationException
                    ' The upgrade request timed out.
                    Interlocked.Increment(writerTimeouts)
                End Try
            
                ' When the lock has been downgraded, it is 
                ' still safe to read from the resource.
                Display("reads resource value " & resource)
                Interlocked.Increment(reads)
            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 'UpgradeDowngrade
    . . . 
End Class 'Test 

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

public class Test
{
    // Declaring the ReaderWriterLock at the class level
    // makes it visible to all threads.
    static ReaderWriterLock rwl = new 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("reads resource value " + resource); 
                Interlocked.Increment(ref 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("writes resource value " + resource);
                        Interlocked.Increment(ref writes);
                    }        
                    finally
                    {
                        // Ensure that the lock is released.
                        rwl.DowngradeFromWriterLock(ref lc);
                    }
                }
                catch (ApplicationException)
                {
                    // The upgrade request timed out.
                    Interlocked.Increment(ref writerTimeouts);
                }

                // When the lock has been downgraded, it is 
                // still safe to read from the resource.
                Display("reads resource value " + resource); 
                Interlocked.Increment(ref reads);
            }        
            finally
            {
                // Ensure that the lock is released.
                rwl.ReleaseReaderLock();
            }
        }
        catch (ApplicationException)
        {
            // The reader lock request timed out.
            Interlocked.Increment(ref readerTimeouts);
        }
    }
    . . . 
}

[C++] 
// The complete code is located in the ReaderWriterLock
// class topic.
#using <mscorlib.dll>

using namespace System;
using namespace System::Threading;

public __gc class Test 
{
public:
    // Declaring the ReaderWriterLock at the class level
    // makes it visible to all threads.
    static ReaderWriterLock* rwl = new 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(S"reads resource value {0}", __box(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(S"writes resource value {0}", __box(resource)));
                        Interlocked::Increment(&writes);

                    }        
                    __finally 
                    {
                        // Ensure that the lock is released.
                        rwl->DowngradeFromWriterLock(__box(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(S"reads resource value {0}", __box(resource))); 
                Interlocked::Increment(&reads);

            }        
            __finally 
            {
                // Ensure that the lock is released.
                rwl->ReleaseReaderLock();
            }
        }
        catch (ApplicationException*) 
        {
            // The reader lock request timed out.
            Interlocked::Increment(&readerTimeouts);

        }
    }
    . . . 
};

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

See Also

ReaderWriterLock Class | ReaderWriterLock Members | System.Threading Namespace

Show:
© 2016 Microsoft