Как проверить, что n методов выполняются параллельно?

Question

Как я могу проверить, что n методов выполняются параллельно?

Parallel.For(0, 10, i => DoSomething(i)); 

... 

void DoSomething(int par) 
{ 
    Console.WriteLine($"Test: {par}"); 
} 

Есть ли тест, который может убедить меня, что DoSomething не выполняется последовательно (Если Console.WriteLine не хороший тест, что может быть очень простой функциональный тест?)

Answer 1

В вашем примере методы будут определенно последовательными, потому что консоль .NET будет synchronize calls from different threads.

Вы можете, однако, проверить идентификатор потока, на котором выполняется метод с использованием Thread.ManagedThreadID или Environment.CurrentManagedThreadId (для .NET 4,5)

class Program 
{ 
    static void Main(string[] args) 
    { 
     // first run with default number of threads 
     Parallel.For(0, 10, i => DoSomething(i)); 
     Console.ReadLine(); 

     // now run with fewer threads... 
     Parallel.For(0, 10, new ParallelOptions{ 
            MaxDegreeOfParallelism = 2 
           }, i => DoSomething(i)); 
     Console.ReadLine(); 
    } 

    static void DoSomething(int par) 
    { 
     int i = Environment.CurrentManagedThreadId; 
     // int i = Thread.ManagedThreadId; -- .NET 4.0 and under 
     Thread.Sleep(200); 
     Console.WriteLine("Test: "+ par.ToString() + 
          ", Thread :" + i.ToString()); 
    } 
} 

Если вы запустите это без Thread.Sleep вы заметите, что только несколько потоков будет использоваться, поскольку вызов будет завершен достаточно быстро, чтобы поток был возвращен в пул вовремя, чтобы получить следующее задание, которое распределяется по очереди.

Добавление сна будет задерживать поток (имитирующий работу) достаточно долго, чтобы в потоковом потоке было больше источников потоков, чтобы своевременно выработать задание.

При параллельном выполнении любой задачи легко проверить, что задачи, по сути, выполняются в отдельных потоках. Однако, независимо от того, получаете ли вы выгоду от производительности, это будет зависеть от того, насколько эффективно эти потоки могут работать. Как вы видели, некоторые операции вызывают конкуренцию на общем ресурсе (например, запись на консоль) и могут препятствовать одновременной работе многих потоков.

Другими источниками разногласий могут быть, например, выделение памяти - если ваши потоки распределяют и выделяют память, то они могут потратить много времени на ожидание своей очереди с менеджером памяти. Это ограничит реальную степень параллелизма, которую вы достигнете.

Answer 2

Не уверен, что я понял, что вы хотите сделать. Вы можете просто посчитать их.

Parallel.For(0, 10, i => DoSomething(i)); 

... 

private static int parallelCounter = 0; 
private static object counterLockObject = new Object(); 
void DoSomething(int par) 
{ 
    int myCounter; 
    lock(counterLockObject) 
    { 
     myCounter = ++parallelCounter; 
    } 
    try 
    { 
     // you probably need something that takes more time to 
     // see anything executing in parallel 
     Console.WriteLine("Current number of parallel threads: {0}", myCounter); 
    } 
    finally 
    { 
     lock(counterLockObject) 
     { 
      parallelCounter--; 
     }   
    } 
} 

Answer 3

Вы можете проверить, сколько методы выполнения в Параллели со следующим кодом:

using System; 
using System.Threading; 
using System.Threading.Tasks; 

namespace ParallelMethodsCounter 
{ 
    class Program 
    { 
     public static int _parallelCounter = 0; 
     public static int _maxParallelExecutionsCount = 0; 

     static void Main(string[] args) 
     { 
      Parallel.For(0, 10, i => DoSomething(i)); 
      Console.WriteLine("MAX PARALLEL EXECUTIONS: {0}", _maxParallelExecutionsCount); 
     } 

     public static void DoSomething(int par) 
     { 
      int currentParallelExecutionsCount = Interlocked.Increment(ref _parallelCounter); 
      InterlockedExchangeIfGreaterThan(ref _maxParallelExecutionsCount, currentParallelExecutionsCount, currentParallelExecutionsCount); 
      Console.WriteLine("Current parallel executions: {0}", currentParallelExecutionsCount); 
      try 
      { 
       //Do your work here 
      } 
      finally 
      { 
       Interlocked.Decrement(ref _parallelCounter); 
      } 
     } 

     public static bool InterlockedExchangeIfGreaterThan(ref int location, int comparison, int newValue) 
     { 
      int initialValue; 
      do 
      { 
       initialValue = location; 
       if (initialValue >= comparison) return false; 
      } 
      while (Interlocked.CompareExchange(ref location, newValue, initialValue) != initialValue); 
      return true; 
     } 
    } 
} 

Но голым в виде, что Parallel.For не будет пытаться выполнением слишком много параллельно, так как он использует нить пул и по умолчанию использует количество потоков, равное числу ваших процессорных ядер. На моей четырехъядерной машине я обычно получаю 2-4 параллельных исполнения с максимальным количеством 5 исполнений (но, конечно, здесь нет строгого ограничения).