如何实现线程以同步对向量进行排序？

Question

我正在创建一个包含整数向量的向量，其想法是通过调用带有线程的冒泡排序来对每个整数向量进行排序，然后打印执行时间。

我试图在每次迭代中实现一个线程但不起作用

vector<int> bubbleSort(vector<int>);

void asynchronousSort(vector<vector<int>> pool){
    double executionTime;

    clock_t tStart = clock();
    for(int i = 0; i < pool.size(); i++){
        thread t (bubbleSort, pool[i]);
        t.join();
    }

    executionTime = (double)(clock() - tStart)/CLOCKS_PER_SEC;
    cout << "Time :" << executionTime<< "s." << endl ;
}

void synchronousSort(vector<vector<int>> pool){
    double executionTime;
    clock_t tStart = clock();

    for(int i = 0; i < pool.size(); i++){
        pool[i] = bubbleSort(pool[i]);
    }

    executionTime = (double)(clock() - tStart)/CLOCKS_PER_SEC;
    cout << "Time :" << executionTime<< "s." << endl ;
}

int main(int argc, const char * argv[]) {

    int selectMethod;
    vector<vector<int>> pool(10);
    //Create 10 lists with 10000 numbers in decrement.
    for (int i = 0; i < 10; i++) {
        vector<int> temp;
        for(int j = 10000; j > 0; j--){
            temp.push_back(j);
        }
        pool.push_back(temp);
    }

    cout << "Select method 1)Asynchronously. 2)Synchronously. (1/2): ";
    cin >> selectMethod;

    if(selectMethod == 1){
        asynchronousSort(pool);
    }else{
        synchronousSort(pool);
    }
    return 0;
}

这两种方法所用的时间相同，而 sinchronousSort 必须更快。

Answer 1

您需要在循环后保留threads 和join。

void asynchronousSort(vector<vector<int>> pool){
    double executionTime;
    vector<thread> threads;

    clock_t tStart = clock();
    for(int i = 0; i < pool.size(); i++){
        threads.emplace_back(bubbleSort, pool[i]); // make threads directly inside the vector
                                                   // saves having to std::move them
    }
    for(thread & t:threads) // now that all the threads are up (and maybe running), join them
    {
        t.join();
    }
    // now we can get the execution time
    // note: unless pool is large you may miss it. 
    executionTime = (double)(clock() - tStart)/CLOCKS_PER_SEC;
    cout << "Time :" << executionTime<< "s." << endl ;
}

请注意，这并不是真正的线程池。线程池是您保留并分配作业的线程池。这只是一堆threads。另请注意，如果线程池需要穿着红色和黑色并与观众交谈，那么你就有一个真正的问题。立即寻求帮助。

Answer 2

如果您有支持执行策略的 C++17 编译器（如 VS2017），则可以选择使用std::for_each(std::execution::par, ...。

#include <algorithm>
#include <execution>

void asynchronousSort(vector<vector<int>>& pool) {
    std::for_each(std::execution::par, pool.begin(), pool.end(), [](auto& v) {
        // used std::sort instead
        std::sort(v.begin(), v.end());
    });
}

Answer 3

在您的 for 循环中，您等待线程完成 (t.join())，因此不会同时进行排序。

for(int i = 0; i < pool.size(); i++){
        thread t (bubbleSort, pool[i]);
        t.join();
    }

改用detach()，然后在函数返回之前等待所有线程（例如，将线程*存储在一个向量中，然后将所有线程加入一个for循环）。

也就是说，线程创建需要时间，因此它可能没有您想象的快速操作那么快。如果这是针对 Windows 的，您可以使用我的 Threadpool API 类，记录在 here。