c# – 这种并行排序合并是否正确实现？

这种并行合并排序是否正确实现？它看起来是正确的,我花了40秒写一个测试,它没有失败.

它的要点是我需要通过每次将数组分成两半来排序.然后我试图确保我出错了asked a question for a sanity check(我自己的理智).我想要一个in place sort但是在看到答案时决定复杂的方式,所以我实现了下面的内容.

当然,没有必要创建一个任务/线程来对4字节数组进行排序,但是要学习线程.是否有任何错误或任何我可以改变,以使这更好.对我来说它看起来很完美,但我想要一些一般的反馈.

static void Main(string[] args)
{
    var start = DateTime.Now;
    //for (int z = 0; z < 1000000; z++)
    int z = 0;
    while(true)
    {
        var curr = DateTime.Now;
        if (curr - start > TimeSpan.FromMinutes(1))
            break;
        var arr = new byte[] { 5, 3, 1, 7, 8, 5, 3, 2, 6, 7, 9, 3, 2, 4, 2, 1 };
        Sort(arr, 0, arr.Length, new byte[arr.Length]);
        //Console.Write(BitConverter.ToString(arr));
        for (int i = 1; i < arr.Length; ++i)
        {
            if (arr[i] > arr[i])
            {
                System.Diagnostics.Debug.Assert(false);
                throw new Exception("Sort was incorrect " + BitConverter.ToString(arr));
            }
        }
        ++z;
    }
    Console.WriteLine("Tried {0} times with success", z);
}
static void Sort(byte[] arr, int leftPos, int rightPos, byte[] tempArr)
{
    var len = rightPos - leftPos;
    if (len < 2)
        return;
    if (len == 2)
    {
        if (arr[leftPos] > arr[leftPos + 1])
        {
            var t = arr[leftPos];
            arr[leftPos] = arr[leftPos + 1];
            arr[leftPos + 1] = t;
        }
        return;
    }
    var rStart = leftPos+len/2;
    var t1 = new Thread(delegate() { Sort(arr, leftPos, rStart, tempArr); });
    var t2 = new Thread(delegate() { Sort(arr, rStart, rightPos, tempArr); });
    t1.Start();
    t2.Start();
    t1.Join();
    t2.Join();
    var l = leftPos;
    var r = rStart;
    var z = leftPos;
    while (l<rStart && r<rightPos)
    {
        if (arr[l] < arr[r])
        {
            tempArr[z] = arr[l];
            l++;
        }
        else
        {
            tempArr[z] = arr[r];
            r++;
        }
        z++;
    }
    if (l < rStart)
        Array.Copy(arr, l, tempArr, z, rStart - l);
    else
        Array.Copy(arr, r, tempArr, z, rightPos - r);
    Array.Copy(tempArr, leftPos, arr, leftPos, rightPos - leftPos);
}

解决方法:

您可以使用任务并行库为线程和更清晰的代码提供更好的抽象.以下示例使用此.

除了使用TPL之外,与代码的主要区别在于它具有截止阈值,低于该截止阈值,无论已启动的线程数如何,都使用顺序实现.这可以防止创建执行非常少量工作的线程.还有一个深度截止值,低于该值时不会创建新线程.这可以防止创建的线程数超过硬件可以根据可用逻辑核心数(Environment.ProcessCount)处理的线程数.

我建议在代码中实现这两种方法,以防止大型数组的线程爆炸,并且无法创建执行非常少量工作的线程,即使对于小型数组也是如此.它还可以为您提供更好的性能.

public static class Sort
{
    public static int Threshold = 150; 

    public static void InsertionSort(int[] array, int from, int to)
    {
        // ...
    }

    static void Swap(int[] array, int i, int j)
    {
        // ...
    }

    static int Partition(int[] array, int from, int to, int pivot)
    {
        // ...
    }

    public static void ParallelQuickSort(int[] array)
    {
       ParallelQuickSort(array, 0, array.Length, 
            (int) Math.Log(Environment.ProcessorCount, 2) + 4);
    }

    static void ParallelQuickSort(int[] array, int from, int to, int depthRemaining)
    {
        if (to - from <= Threshold)
        {
            InsertionSort(array, from, to);
        }
        else
        {
            int pivot = from + (to - from) / 2; // could be anything, use middle
            pivot = Partition(array, from, to, pivot);
            if (depthRemaining > 0)
            {
                Parallel.Invoke(
                    () => ParallelQuickSort(array, from, pivot, depthRemaining - 1),
                    () => ParallelQuickSort(array, pivot + 1, to, depthRemaining - 1));
            }
            else
            {
                ParallelQuickSort(array, from, pivot, 0);
                ParallelQuickSort(array, pivot + 1, to, 0);
            }
        }
    }
}

完整的资源可在http://parallelpatterns.codeplex.com/获得

您可以在http://msdn.microsoft.com/en-us/library/ff963551.aspx阅读有关实施的讨论

标签：c,sorting,multithreading,multicore
来源： https://codeday.me/bug/20190621/1256352.html