¿Cuántos hilos hay en mi método?

Question

He estado buscando en la web esta respuesta y no puedo encontrar nada que realmente me ayude.

Tengo un programa que estoy ejecutando y quiero contar cuántos hilos hay en mi método en un momento dado.

tengo mi código en función main():

Parallel.Invoke(MyMethod,MyMethod,MyMethod,MyMethod); 


private static void MyMethod() 
{ 
    //how many threads are waiting here??? <--- this is what I am after 
    lock (myObj) 
    { 
     //one thread at a time please 
    } 
} 

¿Alguien puede arrojar luz aquí ??

Answer 1

No hay forma de consultar directamente cuántos subprocesos hay en una función determinada. La única manera es hacer el seguimiento manual

private static int s_threadCount; 

private static void MyMethod() { 
    Interlocked.Increment(ref s_threadCount); 
    try { 
    ... 
    } finally { 
    Interlocked.Decrement(ref s_threadCount); 
    } 
} 

Nota: Si este método se puede introducir de forma recursiva esto no va a contar con precisión el número de hilos, sino que contará el número de hilos + número de veces que entraron en la función recursiva .

Answer 2

La única manera de hacerlo sería añadir un contador:

static int counter; 
... 
static void SomeMethod() { 
    int threadsInMethod = Interlocked.Increment(ref counter); 
    try { 
     code here 
    } finally { 
     Interlocked.Decrement(ref counter); 
    } 
} 

Advertencia: si el método es re-entrante va a superar en número a sí mismo mientras anidada.

Answer 3

No esperando muchos simultánea introducir/hojas y no se preocupan por re-entrada:

static int _cThreads; 
static void SomeMethod() 
{ 
    Interlocked.Increment(ref _cThreads); 
    try 
    { 
    /* blah */ 
    } 
    finally 
    { 
    Interlocked.Decrement(ref _cThreads); 
    } 
} 

se preocupan por la re-entrada:

static IDictionary<int, int> _cThreads; // ConcurrentDictionary or alternative thread-safe dictionary 
static void SomeMethod() 
{ 
    if(_cThreads.ContainsKey(Thread.CurrentThread.ManagedThreadId))//note that only this thread will hit this key 
    _cThreads[Thread.CurrentThread.ManagedThreadId]++ 
    else 
    _cThreads[Thread.CurrentThread.ManagedThreadId] = 1; 
    try 
    { 
    /* blah */ 
    //When I care about the count then it's _cThreads.Values.Where(v => v != 0).Count() 
    //which will mutate while we're trying to count it, but then any 
    //answer to this is going to have a degree of staleness 
    /*blah*/ 
    } 
    finally 
    { 
    _cThreads[Thread.CurrentThread.ManagedThreadId]--; 
    } 
} 

Si no se preocupan por re -entrada, pero esperan mucho simultáneo, pero no querrán verificar el total cada vez, luego usar un contador rayado. Esto será notablemente más lento con poca contienda, pero mucho más rápido con alta contención entre núcleos, y puede ser aplicable a su caso.