C++ 理解C+中的代码时出现问题+；：行动中的并发

我正在学习《运行中的并发》（第一版，C++11），在理解第8章第228页的部分代码时遇到了一些问题，其中autor在递归分割数据的上下文中显示了QuickSort的多线程版本

整个守则是：

template<typename T>
struct sorter
{
    struct chunk_to_sort
    {
        std::list<T> data;
        std::promise<std::list<T> > promise;
    };

    thread_safe_stack<chunk_to_sort> chunks;  //this is a thread-safe stack explained somewhere else
    std::vector<std::thread> threads;
    unsigned const max_thread_count;
    std::atomic<bool> end_of_data;

    sorter():
        max_thread_count(std::thread::hardware_concurrency()-1),
        end_of_data(false)
    {}

    ~sorter()
    {
        end_of_data=true;
        for(unsigned i=0;i<threads.size();++i)
        {
            threads[i].join();
        }
    }

    void try_sort_chunk()
    {
        boost::shared_ptr<chunk_to_sort > chunk=chunks.pop();
        if(chunk)
        {
        sort_chunk(chunk);
        }
    }

    std::list<T> do_sort(std::list<T>& chunk_data)
    {
        if(chunk_data.empty())
        {
            return chunk_data;
        }
        std::list<T> result;
        result.splice(result.begin(),chunk_data,chunk_data.begin());
        T const& partition_val=*result.begin();

        typename std::list<T>::iterator divide_point=
            std::partition(chunk_data.begin(),chunk_data.end(),
                           [&](T const& val){return val<partition_val;});

        chunk_to_sort new_lower_chunk;
        new_lower_chunk.data.splice(new_lower_chunk.data.end(),
                                    chunk_data,chunk_data.begin(),
                                    divide_point);

        std::future<std::list<T> > new_lower=
            new_lower_chunk.promise.get_future();
        chunks.push(std::move(new_lower_chunk));
        if(threads.size()<max_thread_count)
        {
            threads.push_back(std::thread(&sorter<T>::sort_thread,this));
        }

        std::list<T> new_higher(do_sort(chunk_data));

        result.splice(result.end(),new_higher);
        while(new_lower.wait_for(std::chrono::seconds(0)) !=
              std::future_status::ready)
        {
            try_sort_chunk();
        }

        result.splice(result.begin(),new_lower.get());
        return result;
    }

    void sort_chunk(boost::shared_ptr<chunk_to_sort > const& chunk)
    {
        chunk->promise.set_value(do_sort(chunk->data));
    }

    void sort_thread()
    {
        while(!end_of_data)
        {
            try_sort_chunk();
            std::this_thread::yield();
        }
    }
};

template<typename T>
std::list<T> parallel_quick_sort(std::list<T> input)
{
    if(input.empty())
    {
        return input;
    }
    sorter<T> s;
    return s.do_sort(input);
}

模板
结构分拣机
{
结构块\u到\u排序
{
std：：列表数据；
承诺；
};
thread_safe_stack chunks；//这是在其他地方解释的线程安全堆栈
向量线程；
无符号常量最大线程数；
std：：数据的原子结束；
分拣机（）：
最大线程数（std:：thread:：hardware\u concurrency（）-1），
_数据的结束（假）
{}
~sorter（）
{
_数据的_结束=真；
对于（无符号i=0；i代码使用
std:：partition
将数据分成两部分：小于分区值的部分和不小于分区值的部分

然后，它使用
std:：list
的
splice
成员函数将小于分区值的节点移动到一个新列表中，并将其添加到块列表中进行排序。如果运行的线程数小于最大值，它将生成一个新线程

然后，代码递归地对剩余的列表进行排序：那些不小于分区值的项目。这可能会产生更多的线程

最后，虽然小于分区值的值列表尚未处理，但该线程随后会处理挂起的块本身。
您能否进一步澄清，您具体不了解的是什么。在提取的代码段中仍然有很多语句，您不能认真期望我们对所有语句进行明确解释。因此，请把更多的注意力集中在那些你无法具体掌握的问题上。请通过添加这些信息来回答你的问题。我将问题编辑为πάνταῥεῖ 建议
    chunk_to_sort new_lower_chunk;
    new_lower_chunk.data.splice(new_lower_chunk.data.end(),
                                chunk_data,chunk_data.begin(),
                                divide_point);

    std::future<std::list<T> > new_lower=
        new_lower_chunk.promise.get_future();
    chunks.push(std::move(new_lower_chunk));
    if(threads.size()<max_thread_count)
    {
        threads.push_back(std::thread(&sorter<T>::sort_thread,this));
    }

    std::list<T> new_higher(do_sort(chunk_data));

    result.splice(result.end(),new_higher);
    while(new_lower.wait_for(std::chrono::seconds(0)) !=
          std::future_status::ready)
    {
        try_sort_chunk();
    }

    result.splice(result.begin(),new_lower.get());
    return result;