Comment faire pour compter le montant de threads simultanés .NET application?

Avoir lu En parallèle.ForEach garde de frai de nouveaux threads je suis toujours dans le doute de savoir si c'est une bonne méthode de comptage du nombre de connexions simultanées il threads?

Ce que je vois, c'est que la méthode de comptage du nombre de simultanément saisis mais pas terminé itérations (boucles) dans Parallel.ForEach.
Est-il synonyme du nombre de threads simultanés de convoyage nombre correct d'exécuter simultanément des threads?
Je ne suis pas un spécialiste, mais je peux imaginer que:

• les threads peuvent être ré-utilisés, alors que son activité échangé quelque part pour continuer plus tard.
• théoriquement le fil engagé pour une boucle de l'activité est maintenue dans le pool de thread une fois la boucle terminée mais pas réutilisé pour un autre
• Ou quelles sont les possibilités de distorsion de la pureté de l'expérience (de threads de comptage)?

De toute façon, comment compter le montant de threads en cours d'exécution .NET de processus, de préférence en C#) code?

Mise à jour:

Donc, si pour suivre les Jeppe Stig Nielsen répondre et de l'utiliser pour compter

directThreadsCount = Process.GetCurrentProcess().Threads.Count;

puis la sortie est, à la fois dans la Version (threadsCount == 7) et de Débogage (threadsCount == 15) mode de fonctionnement est très similaire:

[Job 0 complete. 2 threads remaining but directThreadsCount == 7
[Job 1 complete. 1 threads remaining but directThreadsCount == 7
[Job 2 complete. 2 threads remaining but directThreadsCount == 7
[Job 4 complete. 2 threads remaining but directThreadsCount == 7
[Job 5 complete. 2 threads remaining but directThreadsCount == 7
[Job 3 complete. 2 threads remaining but directThreadsCount == 7
[Job 6 complete. 2 threads remaining but directThreadsCount == 7
[Job 9 complete. 2 threads remaining but directThreadsCount == 7
[Job 7 complete. 1 threads remaining but directThreadsCount == 7
[Job 8 complete. 0 threads remaining but directThreadsCount == 7
FINISHED

Qui est, le nombre de threads ne sont pas toujours en diminuant dire que la méthode citée ci-dessus est incorrect tout System.Diagnostics.ProcessThread donne "Class name is not valid at this point"

Sont mes conclusions correct et pourquoi ne pas ProcessThread être utilisés?

Le code de l'application console C#:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Edit4Posting
{
public class Node
{

  public Node Previous { get; private set; }
  public Node(Node previous)
  {
    Previous = previous;
    }
  }
  public class Edit4Posting
  {

    public static void Main(string[] args)
    {
      int concurrentThreads = 0;
      int directThreadsCount = 0;
      int diagThreadCount = 0;

      var jobs = Enumerable.Range(0, 10);
      Parallel.ForEach(jobs, delegate(int jobNr)
      {
        int threadsRemaining = Interlocked.Increment(ref concurrentThreads);

        int heavyness = jobNr % 9;

        //Give the processor and the garbage collector something to do...
        List<Node> nodes = new List<Node>();
        Node current = null;
        //for (int y = 0; y < 1024 * 1024 * heavyness; y++)
        for (int y = 0; y < 1024 * 24 * heavyness; y++)
        {
          current = new Node(current);
          nodes.Add(current);
        }
        //*******************************
        //uncommenting next line gives: "Class name is not valid at this point"
        //diagThreadCount=System.Diagnostics.ProcessThread
        directThreadsCount = Process.GetCurrentProcess().Threads.Count;
        //*******************************
        threadsRemaining = Interlocked.Decrement(ref concurrentThreads);
        Console.WriteLine(
           "[Job {0} complete. {1} threads remaining but directThreadsCount == {2}",
            jobNr, threadsRemaining, directThreadsCount);
      });
      Console.WriteLine("FINISHED");
      Console.ReadLine();
    }
  }
}

OriginalL'auteur Fulproof | 2013-03-13