Многопоточное сложение элементов массива

class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 10; ++i)
            {
                Thread thread = new Thread(ThreadFunction);
                thread.Start();
                Console.WriteLine("Поток "+i);
            }
            Console.Read();
        }
 
        static void ThreadFunction()
        {
            Console.WriteLine("");
        }
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication16
{
    public class Program
    {
        private static void Main(string[] args)
        {
            int[] a = Enumerable.Range(1, 1000).ToArray();
            int i = GetSum(a);
            Console.WriteLine(i);
            Console.ReadKey();
        }
 
        private static int GetSum(int[] a)
        {
            return GetSum(a, 0, a.Length - 1).Result;
        }
 
        private static async Task<int> GetSum(int[] a, int i, int j)
        {
            if (i == j)
                return a[i];
            if (j - i == 1)
                return a[i] + a[j];
            var task = new Task<int>(() => GetSum(a, i, (i+j)/2).Result);
            var task2 = new Task<int>(() => GetSum(a, (i + j) / 2 + 1, j).Result);
            task.Start();
            task2.Start();
            return await task + await task2;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication16
{
    public class Program
    {
        private static void Main(string[] args)
        {
            int[] a = Enumerable.Range(1, 1000).ToArray();
            int sum = 0;
            Parallel.ForEach(a, i => Interlocked.Add(ref sum, i));
            Console.WriteLine(sum);
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace sum
{
    class Program
    {
        static void Main(string[] args)
        {
            DoBenchmark();
        }
 
        static void DoBenchmark()
        {
            Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime;
            DisableGC();
 
            var arr = Enumerable.Repeat(6, 1005000 * 6).ToArray();
            int correctAnswer = 6 * arr.Length;
 
            var methods = new Func<int[], int>[] { ForSum, ForeachSum, ForEachSum, ParallelForEachSum, LinqSum, ParallelLinqSum, CppSum, CppOmpSum, CppParallelSum };
            var names = new[] { "ForSum", "ForeachSum", "ForEachSum", "ParallelForEachSum", "LinqSum", "ParallelLinqSum", "CppSum", "CppOmpSum", "CppParallelSum" };
 
            for (int index = 0; index < methods.Length; ++index)
            {
                var method = methods[index];
 
                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
 
                long minResult = long.MaxValue;
 
                for (int i = 0; i < 100; ++i)
                {
                    minResult = Math.Min(minResult, TestMethod(method, arr, correctAnswer));
                }
 
                Console.WriteLine("{0}: {1} ticks", names[index], minResult);
            }
        }
 
        static void DisableGC()
        {
            GCLatencyMode oldMode = GCSettings.LatencyMode;
 
            // Make sure we can always go to the catch block, 
            // so we can set the latency mode back to `oldMode`
            RuntimeHelpers.PrepareConstrainedRegions();
 
            GCSettings.LatencyMode = GCLatencyMode.LowLatency;
        }
 
        static long TestMethod(Func<int[], int> foo, int[] arr, int correctAnswer)
        {
            var watch = Stopwatch.StartNew();
 
            if (foo(arr) != correctAnswer)
            {
                return -1;
            }
 
            watch.Stop();
            return watch.ElapsedTicks;
        }
 
        static int ForSum(int[] arr)
        {
            int res = 0;
 
            for (int i = 0; i < arr.Length; ++i)
            {
                res += arr[i];
            }
 
            return res;
        }
 
        static int ForeachSum(int[] arr)
        {
            int res = 0;
 
            foreach (var x in arr)
            {
                res += x;
            }
 
            return res;
        }
 
        static int ForEachSum(int[] arr)
        {
            int res = 0;
 
            Array.ForEach(arr, x => res += x);
 
            return res;
        }
 
        static int ParallelForEachSum(int[] arr)
        {
            int res = 0;
 
            Parallel.ForEach(arr, x => Interlocked.Add(ref res, x));
 
            return res;
        }
 
        static int LinqSum(int[] arr)
        {
            return arr.Sum();
        }
 
        static int ParallelLinqSum(int[] arr)
        {
            return arr.AsParallel().Sum();
        }
 
        static unsafe int CppSum(int[] arr)
        {
            fixed (int* ptr = &arr[0])
            {
                return NativeSum(ptr, arr.Length);
            }
        }
 
        static unsafe int CppOmpSum(int[] arr)
        {
            fixed (int* ptr = &arr[0])
            {
                return NativeOmpSum(ptr, arr.Length);
            }
        }
 
        static unsafe int CppParallelSum(int[] arr)
        {
            fixed (int* ptr = &arr[0])
            {
                return NativeParallelSum(ptr, arr.Length);
            }
        }
 
        [DllImport("libcpp.dll", EntryPoint = "NativeSum")]
        private static extern unsafe int NativeSum(int* arr, int size);
 
        [DllImport("libcpp.dll", EntryPoint = "NativeOmpSum")]
        private static extern unsafe int NativeOmpSum(int* arr, int size);
 
        [DllImport("libcpp.dll", EntryPoint = "NativeParallelSum")]
        private static extern unsafe int NativeParallelSum(int* arr, int size);
    }
}

 static int ManualParallelSum(int[] arr)
        {
            int blockSize = arr.Length / Environment.ProcessorCount;
 
            int blockCount = arr.Length / blockSize + arr.Length % blockSize;
 
            var wHandlers = new ManualResetEvent[blockCount];
             
            int[] tempResults = new int[blockCount];
 
            for (int i = 0; i < blockCount; i++)
            {
                ManualResetEvent handler = (wHandlers[i] = new ManualResetEvent(false));
 
                ThreadPool.UnsafeQueueUserWorkItem(param =>
                    {
                        int subResult = 0;
                        int blockIndex = (int)param;
                        int endBlock = Math.Min(arr.Length, blockSize * blockIndex + blockSize);
                        for (int j = blockIndex * blockSize; j < endBlock; j++)
                        {
                            subResult += arr[j];
                        }
                        tempResults[blockIndex] = subResult;
 
                        handler.Set();
                    }, i);
            }
 
            int res = 0;
 
            for (int block = 0; block < blockCount; ++block)
            {
                wHandlers[block].WaitOne();
                res += tempResults[block];
            }
 
            return res;
        }