这是线程的问题吗？ 如果是这样，我该如何解决？

Question

I'm working on a project that involves 2 separate sorting algorithms running simultaneously. However, when the sorting finishes neither arrays are sorted, even if I run the same algorithm simultaneously. I think it may be an error occurring within threading where one algorithm is taking the calculated answer from the other (but I'm not 100% sure).

It does work when only one algorithm is run.

If this is the problem, do you know how to fix it?

If that isn't the issue, then what is and how do I overcome it?

Here's the code where the error occurs (the algorithms are held within their own classes):

        string algorithmLeft = "";
        string algorithmRight = "";

        if (cboxDropDownLeft.SelectedItem != null)
        {
            algorithmLeft = cboxDropDownLeft.SelectedItem.ToString();
        }
        if (cboxDropDownRight.SelectedItem != null)
        {
            algorithmRight = cboxDropDownRight.SelectedItem.ToString();
        }

        ThreadStart tsLeft = delegate ()
        {
            try
            {
                switch (algorithmLeft)
                {
                    case ("Bubble Sort"):
                        Bubble_Sort bubbleSort = new Bubble_Sort();
                        bubbleSort.sortArray();
                        break;

                    case ("Merge Sort"):
                        Merge_Sort mergeSort = new Merge_Sort();
                        mergeSort.sortArray();
                        break;

                    case ("Quick Sort"):
                        Quick_Sort quickSort = new Quick_Sort();
                        quickSort.sortArray();
                        break;
                }
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }

        };

        ThreadStart tsRight = delegate ()
        {
            try
            {
                switch (algorithmRight)
                {
                    case ("Bubble Sort"):
                        Bubble_Sort bubbleSort = new Bubble_Sort();
                        bubbleSort.sortArray();
                        break;

                    case ("Merge Sort"):
                        Merge_Sort mergeSort = new Merge_Sort();
                        mergeSort.sortArray();
                        break;

                    case ("Quick Sort"):
                        Quick_Sort quickSort = new Quick_Sort();
                        quickSort.sortArray();
                        break;

                }
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }

        };

        if (algorithmLeft != "")
        {
            Thread tLeft = new Thread(tsLeft);
            tLeft.Start();
        }
        if (algorithmRight != "")
        {
            Thread tRight = new Thread(tsRight);
            tRight.Start();
        }

Bubble Sort:

    public override void sortArray()
    {
        try
        {
            int n = arrayToSort.Count - 1;

            for (int loop1 = 0; loop1 < n; loop1++)
            {

                for (int loop2 = n; loop2 > loop1; loop2--)
                {
                    if (((IComparable)arrayToSort[loop2 - 1]).CompareTo(arrayToSort[loop2]) > 0)
                    {
                        object temp = arrayToSort[loop2];
                        arrayToSort[loop2] = arrayToSort[loop2 - 1];
                        arrayToSort[loop2 - 1] = temp;
                    }
                    Thread.Sleep(speed);
                }

            }
        }
        catch (Exception err)
        {
            MessageBox.Show(err.Message);
        }
    }

Merge Sort:

    public override void sortArray()
    {
        try
        {
            sort(arrayToSort, 0, arrayToSort.Count - 1);
        }
        catch (Exception err)
        {
            MessageBox.Show(err.Message);
        }

    }

        public void sort(ArrayList arrayToSort, int left, int right)
    {
        if (left < right)
        {
            int m = left + (right - left) / 2;

            sort(arrayToSort, left, m);
            sort(arrayToSort, m + 1, right);
            merge(arrayToSort, left, m, right);
        }
    }

    public void merge(ArrayList data, int left, int mid, int right)
    {
        int i, j, k;
        int n1 = mid - left + 1;
        int n2 = right - mid;
        ArrayList L = new ArrayList(n1);
        ArrayList R = new ArrayList(n2);

        for (i = 0; i < n1; i++)
        {
            L.Add(data[left + i]);
        }

        for (j = 0; j < n2; j++)
        {
            R.Add(data[mid + 1 + j]);
        }

        i = 0;
        j = 0;
        k = left;

        while (i < n1 && j < n2)
        {
            if (((IComparable)L[i]).CompareTo(R[j]) < 0)
            {
                data[k] = L[i];
                i++;
            }
            else
            {
                data[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1)
        {
            data[k] = L[i];
            i++;
            k++;
            Thread.Sleep(speed);
        }

        while (j < n2)
        {
            data[k] = R[j];
            j++;
            k++;
            Thread.Sleep(speed);
        }
    }

Quick Sort:

    public int partition(ArrayList arrayToSort, int left, int right)
    {
        int pivot = (int)arrayToSort[left];

        while (true)
        {
            while (((IComparable)arrayToSort[left]).CompareTo(pivot) < 0)
            {
                left++;
            }

            while (((IComparable)arrayToSort[right]).CompareTo(pivot) > 0)
            {
                right--;
            }

            if (left < right)
            {
                object temp =arrayToSort[right];
                arrayToSort[right] = arrayToSort[left];
                arrayToSort[left] = temp;
                Thread.Sleep(speed);
            }
            else
            {
                return right;
            }
        }
    }

    public override void sortArray()
    {
        try
        {
            sort(arrayToSort, 0, arrayToSort.Count - 1);
        }
        catch (Exception err)
        {
            MessageBox.Show(err.Message);
        }
    }

    public void sort(ArrayList arr, int left, int right)
    {
        if (left < right)
        {
            int pivot = partition(arr, left, right);

            if (pivot > 1)
            {
                sort(arr, left, pivot - 1);
            }

            if (pivot + 1 < right)
            {
                sort(arr, pivot + 1, right);
            }
        }
    }

Algorithm for the creation of the 2 arrays that are to be sorted:

        ArrayCreator arrayCreator = new ArrayCreator();
        arrayCreator.createArray(arrayLeft);
        arrayRight = arrayLeft;

ArrayCreator:

    public void createArray(ArrayList array)
    {
        for (int i = 0; i < 50; i++)
        {
            Random rnd = new Random();
            int x = rnd.Next(1, 400);
            array.Add(x);
            Thread.Sleep(15);
        }
    }

Answer 1

You have stated that the sorting is working if a single thread is running one of the algorithms, but when you use different algorithms, then the result is no longer right. This means that the threads are preventing each-other from achieving success.

Let me explain: Let's assume you have two threads, T1 and T2. If both of them are comparing x and y then you have two possible scenarios

Scenario1

T1 compares x and y and realizes they need to be swapped T1 swaps x and y T2 copmares x and y and realizes they are in correct order

Result: Success

Scenario2

T1 compares x and y and realizes they need to be swapped T2 compares x and y and realizes they need to be swapped T1 swaps x and y T2 swaps y and x

Result: Failure, T2 was making the comparison after T1 made the comparison, but before T1 made the swap.

As a result, this is unsafe. It is much better to let the Threads sort their own partition of the problem space and then mergesort the sorted subsets.

Answer 2

Cloning arrayLeft solved the problem.

Thanks for all the help, it was much appreciated.