significado - que significa c#

C#Thread seguro rápido(est) contador

Question

¿Cuál es la forma de obtener un contador seguro de subprocesos en C # con el mejor rendimiento posible?

Esto es tan simple como se pone:

public static long GetNextValue()
{
    long result;
    lock (LOCK)
    {
        result = COUNTER++;
    }
    return result;
}

Pero, ¿hay alternativas más rápidas?

Answer 1

Esto sería más simple:

return Interlocked.Increment(ref COUNTER);

MSDN Interlocked.Increment

Answer 2

Pruebe con Interlocked.Increment

Answer 3

Según lo recomendado por otros, Interlocked.Increment tendrá un mejor rendimiento que lock() . Simplemente eche un vistazo a IL y Assembly donde verá que el Increment convierte en una declaración de "bloqueo de bus" y su variable se incrementa directamente (x86) o "se agrega" a (x64).

Esta instrucción de "bloqueo de bus" bloquea el bus para evitar que otra CPU acceda al bus mientras la CPU llamante hace su operación. Ahora, eche un vistazo a IL de la instrucción C # lock() . Aquí verá llamadas a Monitor para comenzar o finalizar una sección.

En otras palabras, la instrucción .Net lock() está haciendo mucho más que el .Net Interlocked.Increment .

ASÍ, si todo lo que quiere hacer es incrementar una variable, Interlock.Increment será más rápido. Revise todos los métodos Interbloqueados para ver las diversas operaciones atómicas disponibles y para encontrar aquellas que se adapten a sus necesidades. Use lock() cuando desee hacer cosas más complejas, como incrementos / decrementos interrelacionados, o para serializar el acceso a recursos que son más complejos que los enteros.

Answer 4

Sugiero que use el incremento de enclavamiento incorporado de .NET en la biblioteca System.Threading.

El siguiente código incrementará una variable larga por referencia y es completamente seguro para subprocesos:

Interlocked.Increment(ref myNum);

Fuente: http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx