c# - ¿Existe un equivalente en ReaderWriterLockSlim que favorezca a los lectores?

.net multithreading

Question

He estado usando ReaderWriterLockSlim por algún tiempo y ha cumplido con mis necesidades hasta este momento. A medida que continúo ReaderWriterLockSlim mi aplicación, encuentro que ReaderWriterLockSlim es un poco subóptimo para mi caso de uso.

Según la documentación (y mi experiencia), favorece a los escritores sobre los lectores (es decir, cuando los lectores y los escritores están en cola, los escritores tendrán preferencia). Sin embargo, necesito un equivalente que favorezca a los lectores. Entiendo los efectos secundarios de dicho componente (en particular, el problema del hambre del escritor).

¿Hay algún equivalente listo para producción que alguien pueda señalar? Gracias.

Answer 1

Según MSDN, ReaderWriterLockSlim favorece a los escritores. Esto significa que cuando hay lectores y escritores en cola, los escritores tendrán preferencia.

Esto puede producir el hambre del lector, el código de prueba para reproducir esto está here . Supongo que la inanición solo puede ocurrir si la escritura es una operación larga, que involucra un cambio de contexto de subproceso. Al menos siempre se reproduce en mi máquina, así que por favor dígame si estoy equivocado.

Por otro lado, ReaderWriterLock de .net 2.0 no produce ni la inanición ni el lector ni el escritor, a costa del rendimiento reducido. Here está el código modificado de la muestra anterior, para mostrar que no está ocurriendo ninguna inanición.

Entonces, volviendo a su pregunta, depende de las funciones que requiera del bloqueo RW. Los bloqueos recursivos, el manejo de excepciones, los tiempos de espera: la mayor coincidencia con el bloqueo RW de calidad de producción que admite todo lo anterior y favorece a los lectores probablemente sea ReaderWriterLock.

También puede adoptar el código del artículo de la wiki que describe el primer problema de los lectores y escritores , pero, por supuesto, deberá implementar todas las funciones requeridas de forma manual, y la implementación tendrá un problema de falta de escritores.

El núcleo de bloqueo probablemente se vea así:

class AutoDispose : IDisposable 
{ 
  Action _action; 
  public AutoDispose(Action action) 
  { 
    _action = action; 
  }
  public void Dispose()
  {
    _action();
  }
}

class Lock
{
  SemaphoreSlim wrt = new SemaphoreSlim(1);
  int readcount=0;

  public IDisposable WriteLock()
  {
    wrt.Wait();
    return new AutoDispose(() => wrt.Release());
  }

  public IDisposable ReadLock()
  {
    if (Interlocked.Increment(ref readcount) == 1)
        wrt.Wait();

    return new AutoDispose(() => 
    {
      if (Interlocked.Decrement(ref readcount) == 0)
         wrt.Release();
    });
  }
}

La comparación del rendimiento de 3 implementaciones, el uso de 3 hilos lector y 3 hilos de escritura, el uso de operaciones simples en la memoria (el uso de una operación de bloqueo prolongada produciría una falta de lectura de lectores para RWLockSlim y una falta de escritura de escritor para el bloqueo personalizado):

Me aseguré de que el compilador no desenrolle el bucle de carga de trabajo, pero podría haber otros escollos que no conozco, así que tome estas medidas con un grano de sal. El código fuente de las pruebas está here .