//实现标准库头文件<numeric>中accumulate函数的并行版本

 #include <iostream>

 #include <thread>

 #include <numeric>

 #include <algorithm>

 #include <vector>

 #include <functional>

 #include <utility>

 using std::thread;

 using std::vector;

 using std::accumulate;

 using std::cout;

 using std::endl;

 template <typename Iterator, typename T> class Accum

 {

 public:

     void operator() (Iterator first, Iterator last, T &sum)

     {

         sum = std::accumulate(first, last, sum);

     }

 };

 template <typename Iterator, typename T>

 T ParallelAccum(Iterator first, Iterator last, T &sum)

 {

     //计算迭代器中包含的元素数量

     const unsigned int len = std::distance(first, last);

     //若迭代器中没有元素则直接返回

     if (!len)

     {

         return sum;

     }

     //每个线程处理的元素的最小数量

     const unsigned int min_per_thread = ;

     //获取线程的最大数量,向上取整

     const unsigned int max_thread = (len -  + min_per_thread) / min_per_thread;

     //获取机器支持的并发线程数

     const unsigned int hardware_thread = thread::hardware_concurrency();

     //取上述两者的较小值,同时避免线程数过少

     const unsigned int num_thread = std::min((hardware_thread !=  ? hardware_thread : ), max_thread);

     //最终实际上每个线程处理的元素个数

     const unsigned int block_size = len / num_thread;

     //保存每个线程累加的结果

     vector<T> results(num_thread);

     //启动比num_thread - 1个线程，因为main函数本身已开启一个线程

     vector<thread> threads(num_thread - );

     //

     cout << "Number of elements: " << len << endl;

     cout << "Hardware concurrency: " << hardware_thread << endl;

     cout << "Maximum number of threads: " << max_thread << endl;

     cout << "Number of threads: " << num_thread << endl;

     cout << "Block size: " << block_size << endl;

     cout << "Started parallel calculating..." << endl;

     //开始并行计算

     Iterator block_begin = first;

     for (unsigned int i = ; i < (num_thread - ); ++i)

     {

         Iterator block_end = block_begin;

         //将迭代器向前推进一个块,到达当前块的末尾位置

         std::advance(block_end, block_size);

         //传递参数,通常情况下thread的构造函数将复制所提供的参数,需要将模板参数转为引用

         threads[i] = thread(Accum<Iterator, T>(), block_begin, block_end, std::ref(results[i]));

         block_begin = block_end;

     }

     //处理最后一个线程,由于block_size = len / num_thread得到的结果不一定为整数,该线程处理剩余的所有元素

     Accum<Iterator, T>()(block_begin, last, results[num_thread - ]);

     //对threads中所有线程调用join()

     std::for_each(threads.begin(), threads.end(), std::mem_fn(&thread::join));

     //

     return accumulate(results.begin(), results.end(), sum);

 }

 int main()

 {

     vector<int> i_vec;

     int sum = ;

     for (int i = ; i != ; ++i)

     {

         i_vec.push_back(i);

     }

     sum = ParallelAccum(i_vec.cbegin(), i_vec.cend(), sum);

     cout << "sum = " << sum << endl;

     system("pause");

     return ;

 }