并行版的std::accumulate

#include<iostream>
#include<thread>
#include<vector>
#include <numeric>
#include<chrono>


template<typename Iterator,typename T>
struct accumulate_block {
	void operator()(Iterator first, Iterator last, T& result)const {
		result = std::accumulate(first, last, result);
	}
};

template<typename Iterator,typename T>

T parallel_accumulate(Iterator first, Iterator last, T init) {
	unsigned long const length = std::distance(first, last);
	if (!length) {
		return init;
	}

	//min_per_thread记录了每个线程至少处理的元素数量
	unsigned long const min_per_thread = 25;

	//记录了基于min_per_thread的最大线程数
	unsigned long const max_threads = (length + min_per_thread - 1) / min_per_thread;

	unsigned long hardware_threads = std::thread::hardware_concurrency();
	//选择了实际使用的线程数，它不超过max_threads，也不超过系统的硬件线程数（如果 hardware_threads 不为0，则使用它；否则默认为2）。
	unsigned long const num_threads = std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
	
	//block_size记录了每个线程应处理的元素数量
	unsigned long const block_size = length / num_threads;

	//resluts用于储存每个线程的计算结果
	std::vector<T>results(num_threads);
	//threads用于储存线程对象
	std::vector<std::thread>threads(num_threads - 1);

	Iterator block_start = first;
	for (unsigned long i = 0; i < (num_threads - 1); i++) {
		Iterator block_end = block_start;
		std::advance(block_end, block_size);
		threads[i] = std::thread(accumulate_block<Iterator, T>(), block_start, block_end, std::ref(results[i]));
		block_start = block_end;
	}

	accumulate_block<Iterator, T>()(block_start, last, results.back());

	for (auto& th : threads) {
		th.join();
	}
	
	return std::accumulate(results.begin(), results.end(), init);
}

int main() {
	std::vector<int> data(1000000, 1);

	int result = parallel_accumulate(data.begin(), data.end(), 0);

	std::cout << "Sum: " << result << std::endl;

	int serial_result = std::accumulate(data.begin(), data.end(), 0);
	std::cout << "Serial Sum: " << serial_result << std::endl;

	if (result == serial_result) {
		std::cout << "Parallel and serial results match!" << std::endl;
	}
	else {
		std::cout << "Parallel and serial results do not match!" << std::endl;
	}

	return 0;
}