多线程编程1-多线程编程-一种简单的应用，divide and conquer_recv

1.线程同步计算和异步计算

1）代码

1）实现同步和异步的演示

#include <iostream>
#include <thread>
#include <future>
#include <cmath>
#include <vector>
#include <cstdlib>

using std::function;

//沉重的计算方法，用多线程来做这件事
double caculate(double v)
{
    if(v<=0) return v;
    return sqrt((v*v+std::sqrt((v-5)*(v+2.5))/2.0)/v);
}

//模板类
template<typename Iter , typename Fun>
double visitRange(Iter iterBegin,Iter iterEnd,Fun func)
{
    double v=0;
    //假如写的一点不高效，高效的用for_each
    for(auto iter = iterBegin;iter!=iterEnd;++iter)
    {
        v+=func(*iter);
    }
    return v;
}

int main()
{
    //1.
    std::vector<double> v;
    for(int i=0 ; i<10000000 ; ++i)
    {
        v.push_back(rand());
    }
    std::cout<<v.size()<<std::endl;
    std::cout<<"分割线：计算容器数据量*****************"<<std::endl;
    
    //2.
    double value =0.0;
    for(auto& info:v)
    {
        value += caculate(info);
    }
    std::cout<<value<<std::endl;
    std::cout<<"分割线:同步**************************"<<std::endl;
    
    //3.一个线程跑前面部分，一个线程跑后面部分
    //不能先计算后创线程，这是同步的
    //应该先用线程去计算，再开主进程计算
    auto iter = v.begin()+ (v.size() /2 ); //iter指向容器中间位置
    double anotherv = 0.0;
    auto iterEnd = v.end();                //iterEnd指向容器尾部
    //std::function, thread参数是function
    //std::thread s();放入一个函数
    std::thread s([&anotherv,iter,iterEnd]()
    {
        anotherv = visitRange(iter,iterEnd,caculate);
    });
    auto halfv = visitRange(v.begin(),iter,caculate);

    //线程回收  
    s.join();
    std::cout<<(halfv+anotherv)<<std::endl;

    return 0;
}

2）区分主线程还是其他的线程–id

通过id判断是在主线程还是其他的线程

#include <iostream>
#include <thread>
#include <future>
#include <cmath>
#include <vector>
#include <cstdlib>

using std::function;

//沉重的计算方法，用多线程来做这件事
double caculate(double v)
{
    if(v<=0) return v;
    return sqrt((v*v+std::sqrt((v-5)*(v+2.5))/2.0)/v);
}

//模板类
template<typename Iter , typename Fun>
double visitRange( std::thread::id id,Iter iterBegin,Iter iterEnd,Fun func)
{
    auto curId = std::this_thread::get_id();
    if(id == curId){
        std::cout<<curId<<" hello main thread\n";
    }else{
        std::cout<<curId<<" hello work thread\n";
    }
    double v=0;
    //假如写的一点不高效，高效的用for_each
    for(auto iter = iterBegin;iter!=iterEnd;++iter)
    {
        v+=func(*iter);
    }
    return v;
}

int main()
{   
    auto mainThreadId = std::this_thread::get_id();  //主线程id
    //1.
    std::vector<double> v;
    for(int i=0 ; i<10000000 ; ++i)
    {
        v.push_back(rand());
    }
    std::cout<<v.size()<<std::endl;
    std::cout<<"分割线：计算容器数据量*****************"<<std::endl;
    
    //2.
    double value =0.0;
    for(auto& info:v)
    {
        value += caculate(info);
    }
    std::cout<<value<<std::endl;
    std::cout<<"分割线:同步**************************"<<std::endl;
    
    //3.一个线程跑前面部分，一个线程跑后面部分
    //不能先计算后创线程，这是同步的
    //应该先用线程去计算，再开主进程计算
    auto iter = v.begin()+ (v.size() /2 ); //iter指向容器中间位置
    double anotherv = 0.0;
    auto iterEnd = v.end();                //iterEnd指向容器尾部
    //std::function, thread参数是function
    //std::thread s();放入一个函数
    std::thread s([&anotherv,mainThreadId,iter,iterEnd]()
    {
        anotherv = visitRange(mainThreadId,iter,iterEnd,caculate);
    });
    auto id = s.get_id()    ;//子线程id
    auto halfv = visitRange(mainThreadId,v.begin(),iter,caculate);

    //线程回收  
    s.join();
    std::cout<<(halfv+anotherv)<<std::endl;

    return 0;
}

3）thread的id作为一个key放在map里面

单线程的某些时候比多线程要快，但是大多数情况下，多线程执行任务更快

#include <iostream>
#include <thread>
#include <future>
#include <cmath>
#include <vector>
#include <chrono>   //用来控制线程与时间相关的操作
#include <cstdlib>
#include <ctime>

using std::function;

//沉重的计算方法，用多线程来做这件事
double caculate(double v)
{
    if(v<=0) return v;
    //线程休息10秒
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    return sqrt((v*v+std::sqrt((v-5)*(v+2.5))/2.0)/v);
}

//模板类
template<typename Iter , typename Fun>
double visitRange( std::thread::id id,Iter iterBegin,Iter iterEnd,Fun func)
{
    auto curId = std::this_thread::get_id();
    if(id == curId){
        std::cout<<curId<<" hello main thread\n";
    }else{
        std::cout<<curId<<" hello work thread\n";
    }
    double v=0;
    //假如写的一点不高效，高效的用for_each
    for(auto iter = iterBegin;iter!=iterEnd;++iter)
    {
        v+=func(*iter);
    }
    return v;
}

int main()
{   
    auto mainThreadId = std::this_thread::get_id();  //主线程id
    //1.
    std::vector<double> v;
    for(int i=0 ; i<1000 ; ++i)
    {
        v.push_back(rand());
    }
    std::cout<<v.size()<<std::endl;
    std::cout<<"分割线：计算容器数据量*****************"<<std::endl;
    
    //2.
    double value =0.0;
    auto nowc1 = clock();
    for(auto& info:v)
    {
        value += caculate(info);
    }
    auto finish1 = clock();
    std::cout<<"single thread:"<<value<<"used:"<<(finish1-nowc1)<<std::endl;
    std::cout<<"分割线:同步**************************"<<std::endl;
    
    //3.一个线程跑前面部分，一个线程跑后面部分
    //不能先计算后创线程，这是同步的
    //应该先用线程去计算，再开主进程计算
    auto iter = v.begin()+ (v.size() /2 ); //iter指向容器中间位置
    double anotherv = 0.0;
    auto iterEnd = v.end();                //iterEnd指向容器尾部
    //std::function, thread参数是function
    //std::thread s();放入一个函数
    auto nowc = clock();
    std::thread s([&anotherv,mainThreadId,iter,iterEnd]()
    {
        anotherv = visitRange(mainThreadId,iter,iterEnd,caculate);
    });
    auto id = s.get_id()    ;//子线程id
    auto halfv = visitRange(mainThreadId,v.begin(),iter,caculate);

    //线程回收  
    s.join();
    auto finish = clock();
    std::cout<<"multithread: "<<(halfv+anotherv)<<"used:"<<(finish-nowc)<<std::endl;

    return 0;
}

2）执行效果

1）实现同步和异步的演示的效果

make g++ -std=c++11 -02 -o test test.cc -lpthread
g++ -std=c++11 test.cc -lpthread

2）区分主线程还是其他的线程的效果

3）thread的id作为一个key放在map里面，测试速度