Postupy: Zápis jednoduché smyčky Parallel.ForEach
Tento článek ukazuje, jak pomocí Parallel.ForEach smyčky povolit paralelismus dat přes jakýkoli System.Collections.IEnumerable zdroj dat.System.Collections.Generic.IEnumerable<T>
Poznámka:
Tato dokumentace používá výrazy lambda k definování delegátů v PLINQ. Pokud výrazy lambda v jazyce C# nebo Visual Basic neznáte, podívejte se na výrazy Lambda v PLINQ a TPL.
Příklad
Tento příklad ukazuje Parallel.ForEach operace náročné na procesor. Když spustíte příklad, náhodně vygeneruje 2 miliony čísel a pokusí se filtrovat na prvočísla. První případ prochází kolekci smyčkou for . Druhý případ iteruje přes kolekci prostřednictvím Parallel.ForEach. Výsledný čas potřebný každou iterací se zobrazí po dokončení aplikace.
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
Smyčka Parallel.ForEach funguje jako smyčka Parallel.For . Smyčka rozdělí zdrojovou kolekci a naplánuje práci na více vláknech na základě systémového prostředí. Čím více procesorů v systému, tím rychleji se spustí paralelní metoda. U některých zdrojových kolekcí může být sekvenční smyčka rychlejší v závislosti na velikosti zdroje a druhu práce, kterou smyčka provádí. Další informace o výkonu naleznete v tématu Potenciální nástrahy v datech a paralelismu úkolů.
Další informace o paralelních smyčkách naleznete v tématu Postupy: Zápis jednoduché smyčky Parallel.For.
Pokud chcete použít smyčku Parallel.ForEach s ne generickou kolekcí, můžete pomocí Enumerable.Cast metody rozšíření převést kolekci na obecnou kolekci, jak je znázorněno v následujícím příkladu:
Parallel.ForEach(nonGenericCollection.Cast<object>(),
currentElement =>
{
});
Parallel.ForEach(nonGenericCollection.Cast(Of Object), _
Sub(currentElement)
' ... work with currentElement
End Sub)
Paralelní LINQ (PLINQ) můžete také použít k paralelizaci zpracování IEnumerable<T> zdrojů dat. PLINQ umožňuje použít deklarativní syntaxi dotazu k vyjádření chování smyčky. Další informace naleznete v tématu Paralelní LINQ (PLINQ).
Kompilace a spuštění kódu
Kód můžete zkompilovat jako konzolovou aplikaci pro rozhraní .NET Framework nebo jako konzolovou aplikaci pro .NET Core.
V sadě Visual Studio existují šablony konzolových aplikací jazyka Visual Basic a C# pro desktopovou verzi Windows a .NET Core.
Z příkazového řádku můžete použít příkazy rozhraní příkazového řádku .NET (například dotnet new console nebo dotnet new console -lang vb) nebo vytvořit soubor a použít kompilátor příkazového řádku pro aplikaci .NET Framework.
Ke spuštění konzolové aplikace .NET Core z příkazového řádku použijte dotnet run složku, která obsahuje vaši aplikaci.
Konzolovou aplikaci spustíte ze sady Visual Studio stisknutím klávesy F5.
