C++11多线程异步执行耗时程序

#include <iostream>
#include <thread>
#include <future>
#include <vector>
#include <mutex>

std::mutex mtx;

using namespace std;
using namespace chrono;

template<typename T>
void Measure(T&& func)
{
//auto start = system_clock::now();
func();
//duration<double> diff = system_clock::now() - start;
//cout << "elapsed: " << diff.count() << " seconds" << endl;
}

int64_t Sum(int64_t start, int64_t end)
{
int64_t s = 0;
for (int64_t i = start; i <= end; ++i) {
s += i;
}
this_thread::sleep_for(std::chrono::milliseconds(10));

return s;
}

void Sum1(int &s)
{
mtx.lock();
for (int i=0; i<1000000; ++i){
s++;
}
mtx.unlock();
}
std::vector<int> g_vec;
auto fn = [&](){
for (int i = 1; i <= 1000000000; ++i)
{
g_vec.emplace_back(i);
}
};

 

int64_t Print(int begin, int end,/*const std::vector<int>& vec*/int array[])
{
int64_t sum = 0;
for (int i = begin; i < end; ++i)
{
sum += array[i];
}
//this_thread::sleep_for(std::chrono::milliseconds(5));
return sum;
}

int main(char* argc, char** argv)
{
//fn();

int nThreadCount = std::thread::hardware_concurrency();
const int64_t N = 1000000;
const int K = 8;
//1和2多线程和单线程操作，耗时比较
//1.异步多线程
auto start0 = system_clock::now();
Measure([&]() {
vector<future<int64_t>> vf;
vf.reserve(K);
int dFactor = N / K;
for (int i=0; i<K; ++i)
{
vf.push_back(async(Sum, i == 0 ? 0 : dFactor*i + 1, dFactor*(i + 1)));
}
int64_t ans = 0;
for (int i = 0; i < K; i++)
{
ans += vf[i].get();
}
cout << "ans0:"<< ans << endl;
});
duration<double> diff0 = system_clock::now() - start0;
cout << "elapsed: ------------" << diff0.count() << " seconds" << endl;

//2.单线程
Measure([N]() {
int64_t ans = Sum(0, N);
cout << "ans:" << ans << endl;
});

/////////////////////////////////////////////
//3.多线程加锁,保证原子性
Measure([]() {
vector<thread> v;
int s = 0;
for (size_t i = 0; i < 4; i++)
{
v.emplace_back(Sum1, std::ref(s));
}

for (int i=0; i<v.size(); ++i)
{
v[i].join();
}

cout << "s: " << s << endl;
});

//用vector大量数据时候耗时
//std::vector<int> vec;
//for (int i=1; i<=N; ++i)
//{
// vec.emplace_back(i);
//}
//线程个数

std::vector<int64_t> values;
auto start1 = system_clock::now();
for (int i = 0; i < 5000; ++i)
{
int* array = new int[N];
for (int i = 1; i <= N; i++)
{
array[i - 1] = i;
}
int nSize = N / K;
int nMod = N % K;
vector<future<int64_t>> vf1;
vf1.reserve(K);
Measure([&]() {
for (int i = 0; i < K; ++i)
{
if (i == K - 1)
{
vf1.emplace_back(std::async(Print, i * nSize, (i + 1) * nSize + nMod, array));
}
else
{
vf1.emplace_back(std::async(Print, i * nSize, (i + 1) * nSize, array));
}
}
int64_t ans = 0;
for (int i = 0; i < K; i++)
{
ans += vf1[i].get();
}
values.emplace_back(ans);
delete[]array;
//cout << "--------ans:----------" << ans << endl;
});
//this_thread::sleep_for(std::chrono::microseconds(10));
}
duration<double> diff1 = system_clock::now() - start1;
cout << "elapsed: ------------" << diff1.count() << " seconds" << endl;
auto start = system_clock::now();
for (int i=0; i<10; ++i)
{
Sum(0, N);
}
duration<double> diff = system_clock::now() - start;
cout << "elapsed: " << diff.count() << " seconds" << endl;
int nCount = values.size();

system("pause");
return 0;
}