我使用多线程
方法实现了一个quicksort
程序,在C++ 中有一个Portfolio 任务。
The method of portfolio tasks is to maintain a queue of tasks. Each free thread picks a task from the portfolio, executes it, if necessary generating new subtasks and placing them in to the portfolio
但我不确定什么是对的!在我看来,在一个 thread
中,该算法比两个或四个 thread
运行得更快。我能以某种方式搞乱同步吗?
感谢任何人帮助我。
代码:
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <ctime>
#include <algorithm>
using namespace std;
//print array
template <typename T>
void print(const vector<T> &arr)
{
for (size_t i = 0; i < arr.size(); i++)
cout << arr[i] << " ";
cout << endl;
}
//queue tasks
queue< pair<int, int> > tasks;
//mutexs for set and queue task
mutex q_mutex, s_mutex;
//condition variable
condition_variable cv;
//set
set<int> ss;
//partition algorithm
template <typename T>
int partition(vector<T> &arr, int l, int r)
{
T tmp = arr[r]; //as pivot element
int i = l - 1;
for (int j = l; j <= r - 1; j++)
if (arr[j] < tmp)
{
i++;
swap(arr[i], arr[j]);
}
swap(arr[i + 1], arr[r]);
i++;
return i;
}
//quick sort
template <typename T>
void quick_sort(vector<T> &arr)
{
while (true)
{
unique_lock<mutex> u_lock(q_mutex); //lock mutex
//sort is fineshed
if ( ss.size() == arr.size() ) //u_lock.unlock()
return;
//if queue task is not empty
if ( tasks.size() > 0 )
{
//get task from queue
pair<int, int> cur_task = tasks.front();
tasks.pop();
int l = cur_task.first, r = cur_task.second;
if (l < r)
{
int q = partition(arr, l, r); //split array
//Add indexes in set
s_mutex.lock();
ss.insert(q);
ss.insert(l);
ss.insert(r);
s_mutex.unlock();
//push new tasks for left and right part
tasks.push( make_pair(l, q - 1) );
tasks.push( make_pair(q + 1, r) );
//wakeup some thread which waiting
cv.notify_one();
}
}
else
//if queue is empty
cv.wait(u_lock);
}
}
//Size array
const int ARR_SIZE = 100000;
//Count threads
const int THREAD_COUNT = 8;
thread thrs[THREAD_COUNT];
//generatin array
void generate_arr(vector<int> &arr)
{
srand(time( NULL ));
std::generate(arr.begin(), arr.end(), [](){return rand() % 10000; });
}
//check for sorting
bool is_sorted(const vector<int> &arr)
{
for (size_t i = 0; i < arr.size() - 1; i++)
if ( ! (arr[i] <= arr[i + 1]) )
return false;
return true;
}
int main()
{
//time
clock_t start, finish;
vector<int> arr(ARR_SIZE);
//generate array
generate_arr(arr);
cout << endl << "Generating finished!" << endl << endl;
cout << "Array before sorting" << endl << endl;
//Before sorting
print(arr);
cout << endl << endl;
cout << "Checking is_sorted finished! The result is " << (is_sorted(arr) == 0? "false": "true") << "." << endl << endl;
//add task
tasks.push( make_pair(0, arr.size() - 1) );
//==================================================
start = clock();
for (int i = 0; i < THREAD_COUNT; i++)
thrs[i] = thread( quick_sort<int>, ref(arr) );
finish = clock();
//==================================================
for (auto& th : thrs)
th.join();
cout << "Sorting finished!" << endl << endl;
cout << "Array after sorting" << endl << endl;
//After sorting
print(arr);
cout << endl << endl;
cout << "Checking is_sorted finished! The result is " << (is_sorted(arr) == 0? "false": "true") << "." << endl << endl;
cout << "Runtime: " << (double)(finish - start) / CLOCKS_PER_SEC << endl;
return 0;
}
最佳答案
影响性能的因素远不止您在解决问题时使用了多少线程。其中,
您需要具有实际的并发性,而不仅仅是多线程。正如@Rakete1111 和@user1034749 都观察到的那样,你没有。
标准快速排序具有良好的引用局部性,尤其是当分区大小变小时,但您的技术会舍弃很多,因为给定数组元素的责任很可能在每次分区时被交换到不同的线程。
此外,互斥操作并不是特别便宜,当分区变小时,相对于实际排序的数量,您会开始做相当多的操作。
使用比物理内核更多的线程没有意义。四个线程可能不会太多,但这取决于您的硬件。
以下是一些可以提高多线程性能的方法:
在方法
quick_sort()
中,不要在实际排序过程中保持互斥体q_mutex
锁定,就像目前您所做的那样(unique_lock
您正在使用的构造函数锁定了互斥锁,并且您在unique_lock
的生命周期内没有解锁它。对于小于某个阈值大小的分区,切换到普通递归技术。您必须进行测试才能找到一个好的特定阈值;也许它需要可调。
在每个分区中,让每个线程只将一个子分区发布到投资组合中;让它递归地处理另一个——或者更好的是,迭代地处理另一个。事实上,让它成为您发布的较小子分区,因为这将更好地限制投资组合的大小。
您还可以考虑增加运行测试的元素数量。 100000 并没有那么多,对于更大的问题,您可能会看到不同的性能特征。 1000000 个元素对于现代硬件上的此类测试来说一点也不合理。
关于c++ - 在 C++ 中使用多线程进行快速排序,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/37334109/