Quanti thread nel mio metodo?

Question

Sto cercando nel web questa risposta e non riesco a trovare nulla che mi faccia davvero.

Ho un programma che sto eseguendo e voglio contare quanti thread sono nel mio metodo in un dato momento.

Ho codice nella mia funzione 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 
    } 
} 

Qualcuno può far luce qui ??

Answer 1

Non c'è modo di interrogare direttamente quanti thread ci sono in una data funzione. L'unico modo è quello di fare tracking manuale

private static int s_threadCount; 

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

Nota: Se questo metodo può essere inserito in modo ricorsivo questo non contare con precisione il numero di thread ma invece contare il numero di thread + numero di volte entravano ricorsivamente la funzione .

Answer 2

L'unico modo per farlo sarebbe quello di aggiungere un contatore:

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

Caveat: se il metodo è ri-entrante esso stesso sovrastimare mentre nidificato.

Answer 3

Non aspettandosi molti simultanea entrare/foglie e non si preoccupano di ri-entrancy:

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

si preoccupano di ri-entrancy:

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]--; 
    } 
} 

Se non si preoccupano re -entrancy, ma si aspettano un sacco di simultanei, ma non vorranno controllare il totale ogni volta, quindi utilizzare un contatore a strisce. Questo sarà sensibilmente più lento con bassa contesa, ma molto più veloce con alta contesa tra core, e potrebbe essere applicabile al tuo caso.