C ++-无法弄清楚如何使用互斥量计算线程

Question

I'm coding a multithreaded merge sort in C++. Context: user runs the program with appropriate flags, eg "./mergeSort 100 -t 20"

The first number stands for how many random numbers should the program generate and sort, the -t flag stands for using threads and the last number stands for maximum number of threads the program should use (when the program reaches the maximum amount of threads, it continues with the standard merge sort without multi threading).

For counting the number of threads I use a global variable number_of_units with the mutex lock, but I just can't, for the life of me, get it right.

The standard merge sort function prints text "standard" and the threaded function prints out "new thread #" with # being the number of new threads that the program can still create. I decrement the counter everytime I start a new thread. Here is a block of main():

cout << "array: ";
printArray(nums);
cout << endl;
mergeSortDirector(sort, nums, 0, nums.size() - 1);
cout << endl << "sorted array: ";
printArray(nums);

the mergeSortDirector just directs the program to the correct sort initially, in this case to the mergeSortThread:

void mergeSortThread(vector<int> &nums, int beg, int end) {

    cout << "new thread " << *number_of_units << endl;

    int mid;

    thread half1;
    thread half2;

    if (beg < end) {
        mid = (beg + end) / 2;

        if(*number_of_units > 1) {

            *number_of_units -= 2;
            mtx.lock();
            half1 = thread(mergeSortThread, std::ref(nums), beg, mid);
            mtx.unlock();
            mtx.lock();
            half2 = thread(mergeSortThread, std::ref(nums), mid + 1, end);
            mtx.unlock();

            half1.join();
            half2.join();

        } else if(*number_of_units == 1) {

            *number_of_units--;
            mtx.lock();
            half1 = thread(mergeSortThread, std::ref(nums), beg, mid);
            mtx.unlock();
            mergeSort(nums, mid + 1, end);

            half1.join();

        } else {
            mergeSort(nums, beg, mid);
            mergeSort(nums, mid + 1, end);
        }

        merge(nums, beg, mid, end);
    }
}

and the standard mergeSort:

void mergeSort(vector<int> &nums, int beg, int end) {

    cout << "standard" << endl;

    int mid;

    if (beg < end) {
        mid = (beg + end) / 2;

        mergeSort(nums, beg, mid);
        mergeSort(nums, mid + 1, end);

        merge(nums, beg, mid, end);
    }
}

The output of the program (with 15 random numbers and maximum 10 threads) is:

array: 660919 974282 721803 971892 908195 137470 226270 609453 19612 988775 652618 298558 125993 598676 489395 

new thread 10
new thread 8
new thread 6
new thread 4
new thread 2
new thread 0
standard
standard
standard
standard
standard
standard
new thread 0
standard
standard
standard
standard
new thread 0
standard
standard
new thread 0
standard
standard
new thread 0
standard
standard
new thread 0
standard
standard

sorted array: 19612 125993 137470 226270 298558 489395 598676 609453 652618 660919 721803 908195 971892 974282 988775 

The problem is that new threads are being made after the counter reaches zero... Does anybody know how can I stop that? I'm assuming it's just my positioning of the mutex locks...

Answer 1

You are not locking the mutex around the point where you modify or read *number_of_units . Put the locks around those usages.

Even if the mutex was locked around these variable accesses, you need to make sure that between the read and modification no other thread tries to read. You can do this by holding the lock until both are done.

You should also use std::lock_guard or std::unique_lock instead of locking the mutex directly.

std::unique_lock lock(mtx);
if(*number_of_units > 1) {

    *number_of_units -= 2;
    lock.unlock();
    [...]

} else if(*number_of_units == 1) {

    *number_of_units--;
    lock.unlock();
    [...]
} else {

    lock.unlock();
    [...]
}

If you are not using C++17, you will need to specify the mutex type for std::unique_lock , eg std::unique_lock<std::mutex> .