Como: Escrever um loop Parallel.ForEach simples
Este artigo mostra como usar um Parallel.ForEach loop para habilitar o paralelismo de dados sobre qualquer System.Collections.IEnumerable fonte de System.Collections.Generic.IEnumerable<T> dados.
Nota
Esta documentação usa expressões lambda para definir delegados no PLINQ. Se você não estiver familiarizado com expressões lambda em C# ou Visual Basic, consulte Expressões lambda em PLINQ e TPL.
Exemplo
Este exemplo demonstra Parallel.ForEach para operações com uso intensivo de CPU. Quando você executa o exemplo, ele gera aleatoriamente 2 milhões de números e tenta filtrar para números primos. O primeiro caso itera sobre a coleção através de um for loop. O segundo caso itera sobre a coleta via Parallel.ForEach. O tempo resultante de cada iteração é exibido quando o aplicativo é concluído.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
namespace ParallelExample
{
class Program
{
static void Main()
{
// 2 million
var limit = 2_000_000;
var numbers = Enumerable.Range(0, limit).ToList();
var watch = Stopwatch.StartNew();
var primeNumbersFromForeach = GetPrimeList(numbers);
watch.Stop();
var watchForParallel = Stopwatch.StartNew();
var primeNumbersFromParallelForeach = GetPrimeListWithParallel(numbers);
watchForParallel.Stop();
Console.WriteLine($"Classical foreach loop | Total prime numbers : {primeNumbersFromForeach.Count} | Time Taken : {watch.ElapsedMilliseconds} ms.");
Console.WriteLine($"Parallel.ForEach loop | Total prime numbers : {primeNumbersFromParallelForeach.Count} | Time Taken : {watchForParallel.ElapsedMilliseconds} ms.");
Console.WriteLine("Press 'Enter' to exit.");
Console.ReadLine();
}
/// <summary>
/// GetPrimeList returns Prime numbers by using sequential ForEach
/// </summary>
/// <param name="inputs"></param>
/// <returns></returns>
private static IList<int> GetPrimeList(IList<int> numbers) => numbers.Where(IsPrime).ToList();
/// <summary>
/// GetPrimeListWithParallel returns Prime numbers by using Parallel.ForEach
/// </summary>
/// <param name="numbers"></param>
/// <returns></returns>
private static IList<int> GetPrimeListWithParallel(IList<int> numbers)
{
var primeNumbers = new ConcurrentBag<int>();
Parallel.ForEach(numbers, number =>
{
if (IsPrime(number))
{
primeNumbers.Add(number);
}
});
return primeNumbers.ToList();
}
/// <summary>
/// IsPrime returns true if number is Prime, else false.(https://en.wikipedia.org/wiki/Prime_number)
/// </summary>
/// <param name="number"></param>
/// <returns></returns>
private static bool IsPrime(int number)
{
if (number < 2)
{
return false;
}
for (var divisor = 2; divisor <= Math.Sqrt(number); divisor++)
{
if (number % divisor == 0)
{
return false;
}
}
return true;
}
}
}
Imports System.Collections.Concurrent
Namespace ParallelExample
Class Program
Shared Sub Main()
' 2 million
Dim limit = 2_000_000
Dim numbers = Enumerable.Range(0, limit).ToList()
Dim watch = Stopwatch.StartNew()
Dim primeNumbersFromForeach = GetPrimeList(numbers)
watch.Stop()
Dim watchForParallel = Stopwatch.StartNew()
Dim primeNumbersFromParallelForeach = GetPrimeListWithParallel(numbers)
watchForParallel.Stop()
Console.WriteLine($"Classical foreach loop | Total prime numbers : {primeNumbersFromForeach.Count} | Time Taken : {watch.ElapsedMilliseconds} ms.")
Console.WriteLine($"Parallel.ForEach loop | Total prime numbers : {primeNumbersFromParallelForeach.Count} | Time Taken : {watchForParallel.ElapsedMilliseconds} ms.")
Console.WriteLine("Press 'Enter' to exit.")
Console.ReadLine()
End Sub
' GetPrimeList returns Prime numbers by using sequential ForEach
Private Shared Function GetPrimeList(numbers As IList(Of Integer)) As IList(Of Integer)
Return numbers.Where(AddressOf IsPrime).ToList()
End Function
' GetPrimeListWithParallel returns Prime numbers by using Parallel.ForEach
Private Shared Function GetPrimeListWithParallel(numbers As IList(Of Integer)) As IList(Of Integer)
Dim primeNumbers = New ConcurrentBag(Of Integer)()
Parallel.ForEach(numbers, Sub(number)
If IsPrime(number) Then
primeNumbers.Add(number)
End If
End Sub)
Return primeNumbers.ToList()
End Function
' IsPrime returns true if number is Prime, else false.(https://en.wikipedia.org/wiki/Prime_number)
Private Shared Function IsPrime(number As Integer) As Boolean
If number < 2 Then
Return False
End If
For divisor = 2 To Math.Sqrt(number)
If number Mod divisor = 0 Then
Return False
End If
Next
Return True
End Function
End Class
End Namespace
Um Parallel.ForEach loop funciona como um Parallel.For loop. O loop particiona a coleção de origem e agenda o trabalho em vários threads com base no ambiente do sistema. Quanto mais processadores no sistema, mais rápido o método paralelo é executado. Para algumas coleções de código-fonte, um loop sequencial pode ser mais rápido, dependendo do tamanho da fonte e do tipo de trabalho que o loop executa. Para obter mais informações sobre desempenho, consulte Armadilhas potenciais em dados e paralelismo de tarefas.
Para obter mais informações sobre loops paralelos, consulte Como escrever um loop Parallel.For simples.
Para usar o Parallel.ForEach loop com uma coleção não genérica, você pode usar o Enumerable.Cast método extension para converter a coleção em uma coleção genérica, conforme mostrado no exemplo a seguir:
Parallel.ForEach(nonGenericCollection.Cast<object>(),
currentElement =>
{
});
Parallel.ForEach(nonGenericCollection.Cast(Of Object), _
Sub(currentElement)
' ... work with currentElement
End Sub)
Você também pode usar o Parallel LINQ (PLINQ) para paralelizar o processamento de fontes de IEnumerable<T> dados. PLINQ permite que você use sintaxe de consulta declarativa para expressar o comportamento de loop. Para obter mais informações, consulte Parallel LINQ (PLINQ).
Compilar e executar o código
Você pode compilar o código como um aplicativo de console para .NET Framework ou como um aplicativo de console para .NET Core.
No Visual Studio, há modelos de aplicativo de console Visual Basic e C# para Windows Desktop e .NET Core.
Na linha de comando, você pode usar os comandos da CLI do .NET (por exemplo, dotnet new console ou dotnet new console -lang vb) ou criar o arquivo e usar o compilador de linha de comando para um aplicativo do .NET Framework.
Para executar um aplicativo de console .NET Core a partir da linha de comando, use dotnet run a partir da pasta que contém seu aplicativo.
Para executar seu aplicativo de console do Visual Studio, pressione F5.
