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

您需要在循环后保留thread和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 ;
}

请注意，这实际上不是线程池。线程池是您保留并分配作业的线程池。这只是一堆thread。还要注意，如果线程池要穿红色和黑色并与听众交谈，那将是一个真正的问题。寻求即时帮助。

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。

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

3 个答案: