ReaderWriterLock Clase

Definición

Espacio de nombres:

System.Threading

Ensamblados:

netstandard.dll, System.Threading.dll

Source:

ReaderWriterLock.cs

Define un bloqueo que admite un escritor y varios lectores.

C#

public sealed class ReaderWriterLock : System.Runtime.ConstrainedExecution.CriticalFinalizerObject

Herencia

Object

CriticalFinalizerObject

ReaderWriterLock

Ejemplos

En el ejemplo siguiente se muestra cómo usar para ReaderWriterLock proteger un recurso compartido, un valor entero denominado resource, que se lee simultáneamente y se escribe exclusivamente por varios subprocesos. Tenga en cuenta que ReaderWriterLock se declara en el nivel de clase para que sea visible para todos los subprocesos.

C#

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

   const int numThreads = 26;
   static bool running = true;

   // Statistics.
   static int readerTimeouts = 0;
   static int writerTimeouts = 0;
   static int reads = 0;
   static int writes = 0;

   public static void Main()
   {
      // Start a series of threads to randomly read from and
      // write to the shared resource.
      Thread[] t = new Thread[numThreads];
      for (int i = 0; i < numThreads; i++){
         t[i] = new Thread(new ThreadStart(ThreadProc));
         t[i].Name = new String((char)(i + 65), 1);
         t[i].Start();
         if (i > 10)
            Thread.Sleep(300);
      }

      // Tell the threads to shut down and wait until they all finish.
      running = false;
      for (int i = 0; i < numThreads; i++)
         t[i].Join();

      // Display statistics.
      Console.WriteLine("\n{0} reads, {1} writes, {2} reader time-outs, {3} writer time-outs.",
            reads, writes, readerTimeouts, writerTimeouts);
      Console.Write("Press ENTER to exit... ");
      Console.ReadLine();
   }

   static void ThreadProc()
   {
      Random rnd = new Random();

      // Randomly select a way for the thread to read and write from the shared
      // resource.
      while (running) {
         double action = rnd.NextDouble();
         if (action < .8)
            ReadFromResource(10);
         else if (action < .81)
            ReleaseRestore(rnd, 50);
         else if (action < .90)
            UpgradeDowngrade(rnd, 100);
         else
            WriteToResource(rnd, 100);
      }
   }

   // Request and release a reader lock, and handle time-outs.
   static void ReadFromResource(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);
         }
         finally {
            // Ensure that the lock is released.
            rwl.ReleaseReaderLock();
         }
      }
      catch (ApplicationException) {
         // The reader lock request timed out.
         Interlocked.Increment(ref readerTimeouts);
      }
   }

   // Request and release the writer lock, and handle time-outs.
   static void WriteToResource(Random rnd, int timeOut)
   {
      try {
         rwl.AcquireWriterLock(timeOut);
         try {
            // It's safe for this thread to access 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.ReleaseWriterLock();
         }
      }
      catch (ApplicationException) {
         // The writer lock request timed out.
         Interlocked.Increment(ref writerTimeouts);
      }
   }

   // Requests a reader lock, upgrades the reader lock to the writer
   // lock, and downgrades it to a reader lock again.
   static void UpgradeDowngrade(Random rnd, int timeOut)
   {
      try {
         rwl.AcquireReaderLock(timeOut);
         try {
            // It's safe for this thread to read from the shared resource.
            Display("reads resource value " + resource);
            Interlocked.Increment(ref reads);

            // To write to the resource, either release the reader lock and
            // request the writer lock, or upgrade the reader lock. 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's 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);
            }

            // If the lock was downgraded, it's 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);
      }
   }

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

   // Helper method briefly displays the most recent thread action.
   static void Display(string msg)
   {
      Console.Write("Thread {0} {1}.       \r", Thread.CurrentThread.Name, msg);
   }
}

Comentarios

Importante

.NET Framework tiene dos bloqueos de escritor de lectura y ReaderWriterLockSlimReaderWriterLock. ReaderWriterLockSlim se recomienda para todos los nuevos desarrollos. ReaderWriterLockSlim es similar a ReaderWriterLock, pero se han simplificado las reglas para la recursividad y para actualizar y degradar el estado de bloqueo. ReaderWriterLockSlim evita muchos casos de interbloqueo potencial. Además, el rendimiento de ReaderWriterLockSlim es significativamente mayor que ReaderWriterLock.

ReaderWriterLock se usa para sincronizar el acceso a un recurso. En un momento dado, permite el acceso de lectura simultáneo para varios subprocesos o el acceso de escritura para un único subproceso. En una situación en la que un recurso se cambia con poca frecuencia, proporciona ReaderWriterLock un mejor rendimiento que un bloqueo simple de uno a uno, como Monitor.

ReaderWriterLock funciona mejor donde la mayoría de los accesos son lecturas, mientras que las escrituras son poco frecuentes y de corta duración. Varios lectores se alternan con escritores únicos, de modo que ni los lectores ni los escritores se bloqueen durante largos períodos.

Nota

Mantener bloqueados de lector o bloqueos de escritor durante largos períodos se verán abocados a otros subprocesos. Para obtener el mejor rendimiento, considere la posibilidad de reestructurar la aplicación para minimizar la duración de las escrituras.

Un subproceso puede contener un bloqueo de lector o un bloqueo de escritor, pero no ambos al mismo tiempo. En lugar de liberar un bloqueo de lector para adquirir el bloqueo del escritor, puede usar UpgradeToWriterLock y DowngradeFromWriterLock.

Las solicitudes de bloqueo recursiva aumentan el número de bloqueos en un bloqueo.

Los lectores y escritores se ponen en cola por separado. Cuando un subproceso libera el bloqueo del escritor, se conceden bloqueos de lector a todos los subprocesos que esperan en la cola del lector; cuando se han liberado todos esos bloqueos de lector, se concede el siguiente subproceso que espera en la cola del escritor, si existe, el bloqueo del escritor, etc. En otras palabras, ReaderWriterLock alterna entre una colección de lectores y un escritor.

Mientras un subproceso de la cola del escritor está esperando que se liberen bloqueos de lector activos, los subprocesos que solicitan nuevos bloqueos de lector se acumulan en la cola del lector. No se conceden sus solicitudes, aunque pudieran compartir acceso simultáneo con los titulares de bloqueo de lector existentes; esto ayuda a proteger a los escritores contra bloqueos indefinidos por parte de los lectores.

La mayoría de los métodos para adquirir bloqueos en valores ReaderWriterLock de tiempo de espera aceptados. Use tiempos de espera para evitar interbloqueos en la aplicación. Por ejemplo, un subproceso podría adquirir el bloqueo del escritor en un recurso y, a continuación, solicitar un bloqueo de lector en un segundo recurso; mientras tanto, otro subproceso podría adquirir el bloqueo del escritor en el segundo recurso y solicitar un bloqueo de lector en el primero. A menos que se usen tiempos de espera, los subprocesos se interbloquean.

Si el intervalo de tiempo de espera expira y no se ha concedido la solicitud de bloqueo, el método devuelve el control al subproceso que realiza la llamada iniciando una ApplicationExceptionexcepción . Un subproceso puede detectar esta excepción y determinar qué acción realizar a continuación.

Los tiempos de espera se expresan en milisegundos. Si usa un System.TimeSpan para especificar el tiempo de espera, el valor usado es el número total de milisegundos enteros representados por .TimeSpan En la tabla siguiente se muestran los valores de tiempo de espera válidos en milisegundos.

Valor	Descripción
-1	El subproceso espera hasta que se adquiere el bloqueo, independientemente del tiempo que tarde. Para los métodos que especifican tiempos de espera enteros, se puede usar la constante Infinite .
0	El subproceso no espera a adquirir el bloqueo. Si el bloqueo no se puede adquirir inmediatamente, el método devuelve.
>0	Número de milisegundos durante los que se va a esperar.

A excepción de -1, no se permiten valores de tiempo de espera negativos. Si especifica un entero negativo distinto de -1, se usa en su lugar un valor de tiempo de espera de cero. (Es decir, el método devuelve sin esperar, si el bloqueo no se puede adquirir inmediatamente). Si especifica un TimeSpan que representa un número negativo de milisegundos distintos de -1, ArgumentOutOfRangeException se produce .

Constructores

ReaderWriterLock()

Inicializa una nueva instancia de la clase ReaderWriterLock.

Propiedades

IsReaderLockHeld	Obtiene un valor que indica si el subproceso actual tiene un bloqueo de lector.
IsWriterLockHeld	Obtiene un valor que indica si el subproceso actual tiene el bloqueo de escritor.
WriterSeqNum	Obtiene el número de secuencia actual.

Métodos

AcquireReaderLock(Int32)	Adquiere un bloqueo de lector, utilizando un valor Int32 para el tiempo de espera.
AcquireReaderLock(TimeSpan)	Adquiere un bloqueo de lector, utilizando un valor TimeSpan para el tiempo de espera.
AcquireWriterLock(Int32)	Adquiere el bloqueo de escritor, utilizando un valor Int32 para el tiempo de espera.
AcquireWriterLock(TimeSpan)	Adquiere el bloqueo de escritor, utilizando un valor TimeSpan para el tiempo de espera.
AnyWritersSince(Int32)	Indica si se ha concedido el bloqueo de escritor a algún subproceso desde que se obtuvo el número de secuencia.
DowngradeFromWriterLock(LockCookie)	Recupera el estado de bloqueo del subproceso al estado que tenía antes de llamar a UpgradeToWriterLock(Int32).
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ReleaseLock()	Libera el bloqueo, independientemente del número de veces que el subproceso haya adquirido el bloqueo.
ReleaseReaderLock()	Reduce el recuento de bloqueos.
ReleaseWriterLock()	Reduce el recuento de bloqueos del bloqueo de escritor.
RestoreLock(LockCookie)	Restaura el estado de bloqueo del subproceso al estado que tenía antes de llamar a ReleaseLock().
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
UpgradeToWriterLock(Int32)	Actualiza un bloqueo de lector al bloqueo de escritor, utilizando un valor Int32 para el tiempo de espera.
UpgradeToWriterLock(TimeSpan)	Actualiza un bloqueo de lector al bloqueo de escritor utilizando un valor TimeSpan para el tiempo de espera.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también

• Subprocesamiento administrado
• ReaderWriterLock