ReaderWriterLock.ReleaseLock メソッド

.NET Framework クラス ライブラリ リファレンス

ReaderWriterLock.ReleaseLock メソッド

スレッドがロックを取得した回数に関係なく、ロックを解放します。

名前空間: System.Threading
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public Function ReleaseLock As
 LockCookie

Visual Basic (使用法)

Dim instance As ReaderWriterLock
Dim returnValue As LockCookie

returnValue = instance.ReleaseLock

C#

public LockCookie ReleaseLock ()

C++

public:
LockCookie ReleaseLock ()

J#

public LockCookie ReleaseLock ()

JScript

public function ReleaseLock () : LockCookie

戻り値
解放されたロックを表す LockCookie 値。

解説

ReleaseLock を呼び出すと、再帰的なロック カウントに関係なく、リーダー ロックまたはライタ ロックが解放されます。ロック カウントも含め、ロックの状態を復元するには LockCookie を RestoreLock に渡します。

使用例

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
<br /><span space="preserve">...</span><br
 />    ' 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.
    Shared Sub ReleaseRestore(timeOut As
 Integer)
        Dim lastWriter As Integer
      
        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.)
                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 (up to a 
                ' quarter of a second), and then restore
                ' the previous state of the lock. Note that
                ' there is no time-out 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) 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 'ReleaseRestore
<br /><span space="preserve">...</span><br
 />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;
<br /><span space="preserve">...</span><br /> 
   // 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(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("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 (up to a 
                // quarter of a second), and then restore
                // the previous state of the lock. Note that
                // there is no time-out on the Restore method.
                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);
        }
    }
<br /><span space="preserve">...</span><br />}

C++

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

<br /><span space="preserve">...</span><br /> 
  // 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( 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 );
      }

   }


<br /><span space="preserve">...</span><br />};

J#

// The complete code is located in the ReaderWriterLock
// class topic.
import System.*;
import System.Threading.*;
import System.Threading.Thread;    

public class Test
{
    // Declaring the ReaderWriterLock at the class level
    // makes it visible to all threads.
    private static ReaderWriterLock rwl = new
 ReaderWriterLock();

    // For this example, the shared resource protected by the
    // ReaderWriterLock is just an integer.
    private static int resource
 = 0;
<br /><span space="preserve">...</span><br />
    // 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(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(("reads resource value " + resourceValue));
                Interlocked.Increment(reads);

                // Save the current writer sequence number.
                lastWriter = rwl.get_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 time-out 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(("resource has changed " + resourceValue));
                }
                else {
                    Display(("resource has not changed " + resourceValue));
                }
            }
            finally {
                // Ensure that the lock is released.
                rwl.ReleaseReaderLock();
            }
        }
        catch (ApplicationException exp) {
            // The reader lock request timed out.
            Interlocked.Increment(readerTimeouts);
        }
    } //ReleaseRestore
<br /><span space="preserve">...</span><br />}

プラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0

参照

関連項目
ReaderWriterLock クラス
ReaderWriterLock メンバ
System.Threading 名前空間
その他の技術情報
マネージ スレッド処理
読み取り/書き込みロック