【C++11】多线程并行化快速排序的实现

基础

并行化可以优化许多算法，前提是并行化的任务之间不会产生冲突。快速排序的核心逻辑为分治，通过一次遍历，使得区间分成了两个子区间，其中一个子区间的元素恒小于等于另一个区间的元素，再用同样的方法分别处理这两个子区间。可以发现，这两个子区间不重叠，并且后续的操作都是在一个区间内继续完成，不会跨区间，因此满足了并行化的条件。

通常的一种用多线程来解决问题的方式是使用线程池，将需要完成的操作细化成任务，传入线程池，空闲的线程会去完成这些任务。对于并行化快排来说，对较大的区间[p, q]进行partition操作分为两个子区间或对较小的区间直接进行快速排序就是它的任务。不过与普通的线程池操作不同，该任务的完成可能会创造新的任务，即这个任务可能有“返回值”，因此需要对通用线程池进行扩展，满足并行化快速排序的特定需求。具体实现细节见后文。

其他的一些优化

由于线程的切换存在时间开销，因此并行化任务不会无限对区间进行细分，当区间长度小于阈值时，使用串行化快排。

由于插入排序对小范围区间的排序处理效果更好，因此在区间范围小于16的情况下，不再使用快速排序，而是插入排序（STL里的sort也是这么做的）。

实现

Task包括一个需要排序的数组，和具体需要排序的区间 [p, q]

template <typename T>
class Task {
   
    public:
        Task(T &vec, int p, int q) : vec_(vec), p_(p), q_(q) {
   }
        T &vec_;
        int p_, q_;
};

任务队列主要的数据为一个包含Task的Queue，为了保证Queue操作的原子性，使用了mutex，condition_variable用于使得Get操作在Queue为空时，能够阻塞等待，直到新插入一个Task

template <typename T>
class TaskQueue {
   
    public:
        Task<T> Get();
        void Push(Task<T> &&task);
        bool Empty();

    private:
        std::queue<Task<T> > que_;
        std::mutex mutex_;
        std::condition_variable cond_var_;
};

template <typename T>
Task<T> TaskQueue<T>::Get() {
   
    std::unique_lock<std::mutex> lk(mutex_);
    while(que_.empty()) {
   
        cond_var_.wait(lk);
    }
    Task<T> ans = que_.front();
    que_.pop();
    return ans;
}

template <typename T>
void TaskQueue<T>::Push(Task<T> &&task) {
   
    std::lock_guard<std::mutex> lk(mutex_);
    que_.push(std::move(task));
    cond_var_.notify_one();
}

template <typename T>
bool TaskQueue<T>::Empty() {
   
    std::lock_guard<std::mutex> lk(mutex_);
    return que_.empty();
}

CQSort 为主要的并行排序类，整体逻辑类似一个线程池

void SequentialSort_(T &vec, int p, int q);

void InsertSort_(T &vec, int p, int q);

int Partition_(T &vec, int p, int q);

上述三个函数是基础的排序方法，分别为串行化快排、插入排序和快排的Partition操作

void ThreadFunc_() 为线程池中线程执行的入口，不断从Queue中取出Task执行直到排序完成

void ConcurrentSort_(T &vec) 为并行化快排开始的入口，创建一个Task并插入到Queue中

void doConcurrentSort_(T &vec, int p, int q) 具体执行快排的代码，在Partiton后继续执行其中一半，另一半存入任务队列。若待排序区间长度小于512，则使用串行化快排。

mThr_ 为线程的数量

idleThr_ 为空闲线程的数量

std::vector < std::future < void>> asyncVec 存储执行的线程

bool isEnd 为线程池结束的标识符，当所有线程都空闲，并且任务队列为空，则认为排序已完成

template <typename T>
class CQSort {
   
public:
    CQSort(int mthr);
    ~CQSort();
    void operator()(T &vec);

private:
    void SequentialSort_(T &vec, int p, int q);
    void InsertSort_(T &vec, int p, int q);
    int Partition_(T &vec, int p, int q);
    void ConcurrentSort_(T &vec);
    void doConcurrentSort_(T &vec, int p, int q);
    void ThreadFunc_();

private:
    const int mThr_;
    std::mutex idleMutex_;
    int idleThr_;
    std::vector<std::future<void>> asyncVec;
    TaskQueue<T> taskQue;
    std::mutex endMutex_;
    std::condition_variable endCond_;
    bool isEnd;
};

template<typename T>
CQSort<T>::CQSort(int mthr) : mThr_(mthr), idleThr_(mthr), isEnd(false) {
    //mthr 线程数量
    for(int i = 0; i < mThr_; ++i) {
   
        asyncVec.push_back(std::async(std::launch::async, bind(&CQSort<T>::ThreadFunc_, this)));
    }
}

// 正式开始排序
template <typename T>    
void CQSort<T>::operator()(T &vec) {
   
    if(mThr_ <= 1) {
   
        SequentialSort_(vec, 0, vec.size() - 1);
    }
    else {
   
        ConcurrentSort_(vec);
    }
}

template <typename T>
CQSort<T>::~CQSort() {
   
    if(mThr_ <= 1) {
   
        return;
    }
    T tmp;
    int n = mThr_;
    while((n--) != 0) {
   
        taskQue.Push(Task<T>{
   tmp, 0, 0});
    }
    while(!asyncVec.empty()) {
   
        asyncVec.pop_back();
    }
}

template <typename T>
void CQSort<T>::SequentialSort_(T &vec, int p, int q) {