Распараллеливание процессов

#region using
 
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
 
#endregion
 
namespace ConsoleApplicationTest
{
    public static class Program
    {
        private static void Main()
        {
            for (var num = 0; num < 6; num++)
            {
                // Получаем диапазон от 0 до 1000
                var source = Enumerable.Range(0, 500000).ToArray();
                // Запускаем таймер
                var stopwatch = Stopwatch.StartNew();
                // Вычисляем сумму не параллельно.
                var sum = source
                    // Вычислем для каждого числа квадрат его косинуса
                    .Select(i => Math.Pow(Math.Cos((double) i/100), 2))
                    // Суммируем полученные значения
                    .Sum();
                // Останавливаем таймер
                stopwatch.Stop();
 
                Console.WriteLine(sum);
                Console.WriteLine("не параллельно  " + stopwatch.Elapsed);
 
                // Перезапускаем таймер
                stopwatch.Restart();
                // Вычисляем сумму параллельно с помощью PLinq
                sum = source
                    // Переключаемся на PLinq
                    .AsParallel()
                    .Select(i => Math.Pow(Math.Cos((double) i/100), 2))
                    .Sum();
                stopwatch.Stop();
 
                // Выводим результат и затраченное время.
                Console.WriteLine(sum);
                Console.WriteLine("параллельно1    " + stopwatch.Elapsed);
 
                sum = 0;
                // Объект для управления блокировкой.
                var lockObj = new object();
 
                stopwatch.Restart();
                // Вычисляем сумму параллельно с помощью Parallel.For
                Parallel.For(0, source.Length, i =>
                                                   {
                                                       // Вычисляем текущее значение
                                                       var x = Math.Pow(Math.Cos((double) source[i]/100), 2);
                                                       // Блокируем доступ к sum из других потоков
                                                       // Если убрать блокировку, то в sum может получится неверное значение.
                                                       lock (lockObj)
                                                       {
                                                           // Прибавляем значение к sum
                                                           sum += x;
                                                       }
                                                   });
                stopwatch.Stop();
 
                Console.WriteLine(sum);
                Console.WriteLine("параллельно2    " + stopwatch.Elapsed);
 
                sum = 0;
                // Разбиваем исходный массив на несколько частей, в зависимости от количества ядер
                var rangePartitioner = Partitioner.Create(0, source.Length);
 
                stopwatch.Restart();
                // Вычисляем сумму параллельно с помощью  Parallel.ForEach
                // Как можно заметить, наиболее производительный способ в данном случае.
                // В каждом потоке выполняется свой цикл по части массива, 
                // что обеспечивает большую производительность при несложных вычислениях на каждой итерации.
                Parallel.ForEach(rangePartitioner,
                                 // range - начальный и конечный индексы части массива, которую необходимо обработать в данном потоке.
                                 // loopState - состояние потока.
                                 (range, loopState) =>
                                     {
                                         // Вычисляем сумму для части массива.
                                         var x = 0d;
                                         for (var i = range.Item1; i < range.Item2; i++)
                                             x += Math.Pow(Math.Cos((double) source[i]/100), 2);
                                         // Прибавляем её к общей сумме.
                                         lock (lockObj)
                                         {
                                             sum += x;
                                         }
                                     });
                stopwatch.Stop();
 
                Console.WriteLine(sum);
                Console.WriteLine("параллельно3    " + stopwatch.Elapsed);
 
                sum = 0;
                stopwatch.Restart();
                // Вычисляем сумму параллельно с помощью  Parallel.For
                // Принцип аналогичен предыдущему примеру.
 
                Parallel.For(
                    // Начальный и конечный индексы цикла
                    0, source.Length, // Начальный и конечный индексы цикла
                    // Начальное значение внутренней переменной, локальной для каждого цикла.
                    () => 0d,
                    // Функция, выполняющаяся при каждой итерации.
                    // i - текущий индекс.
                    // loopState - состояние потока.
                    // subtotal - локальная переменная потока.
                    // Прибавляем к локальной переменной её предыдущее значение + Math.Pow(Math.Cos..
                    (i, loopState, subtotal) => subtotal + Math.Pow(Math.Cos((double) source[i]/100), 2),
                    // Действие, вызываемое когда поток заканчивается.
                    subtotal =>
                        {
                            // Прибавляем итоговое значение локальной переменной к общей сумме.
                            lock (lockObj)
                            {
                                sum += subtotal;
                            }
                        }
                    );
                stopwatch.Stop();
 
                Console.WriteLine(sum);
                Console.WriteLine("параллельно4    " + stopwatch.Elapsed);
                Console.WriteLine("----------------------");
            }
 
            Console.ReadKey();
        }
    }
}

using System;
using System.Threading;
 
public class Fibonacci
{
    private int _n;
    private int _fibOfN;
    private ManualResetEvent _doneEvent;
 
    public int N { get { return _n; } }
    public int FibOfN { get { return _fibOfN; } }
 
    // Constructor.
    public Fibonacci(int n, ManualResetEvent doneEvent)
    {
        _n = n;
        _doneEvent = doneEvent;
    }
 
    // Wrapper method for use with thread pool.
    public void ThreadPoolCallback(Object threadContext)
    {
        int threadIndex = (int)threadContext;
        Console.WriteLine("thread {0} started...", threadIndex);
        _fibOfN = Calculate(_n);
        Console.WriteLine("thread {0} result calculated...", threadIndex);
        _doneEvent.Set();
    }
 
    // Recursive method that calculates the Nth Fibonacci number.
    public int Calculate(int n)
    {
        if (n <= 1)
        {
            return n;
        }
 
        return Calculate(n - 1) + Calculate(n - 2);
    }
}
 
public class ThreadPoolExample
{
    static void Main()
    {
        const int FibonacciCalculations = 10;
 
        // One event is used for each Fibonacci object.
        ManualResetEvent[] doneEvents = new ManualResetEvent[FibonacciCalculations];
        Fibonacci[] fibArray = new Fibonacci[FibonacciCalculations];
        Random r = new Random();
 
        // Configure and start threads using ThreadPool.
        Console.WriteLine("launching {0} tasks...", FibonacciCalculations);
        for (int i = 0; i < FibonacciCalculations; i++)
        {
            doneEvents[i] = new ManualResetEvent(false);
            Fibonacci f = new Fibonacci(r.Next(20, 40), doneEvents[i]);
            fibArray[i] = f;
            ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
        }
 
        // Wait for all threads in pool to calculate.
        WaitHandle.WaitAll(doneEvents);
        Console.WriteLine("All calculations are complete.");
 
        // Display the results.
        for (int i = 0; i < FibonacciCalculations; i++)
        {
            Fibonacci f = fibArray[i];
            Console.WriteLine("Fibonacci({0}) = {1}", f.N, f.FibOfN);
        }
        Console.ReadLine();
    }
}