C++多线程编程(一)（使用C++11后的thread类）

最新推荐文章于 2024-01-07 11:36:40 发布
最新推荐文章于 2024-01-07 11:36:40 发布
阅读量139 收藏 1
点赞数
分类专栏： C++STL C++基础 文章标签： c++ 多线程 thread
原文链接：https://www.cnblogs.com/douzujun/p/10810506.html https://www.cnblogs.com/douzujun/p/10816335.html https://www.cnblogs.com/douzujun/p/10841797.html
版权

以下程序代码参考来源于
https://www.cnblogs.com/douzujun/p/10810506.html
https://www.cnblogs.com/douzujun/p/10816335.html
本篇只是自己学习的笔记，部分代码添加了自己理解的注释。

一、一个多线程程序示例，与单线程比较

//====================把一个复杂的计算拆分多线程实现的方式，与单线程做比较，可以看到多线程的好处==============
#include<iostream>
#include<thread>
#include<vector>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <future>
using namespace std;

double caculate(int v){
    if(v<=0){
        return v;
    }
    //假设这个计算过程很慢
    this_thread::sleep_for(chrono::milliseconds(10));
    return sqrt((v*v +sqrt((v-5)*(v*2.5))/2.0)/v);
}

template <typename Iter,typename Fun>
double visitRange(thread::id id,Iter iterBegin,Iter iterEnd,Fun func){
    auto curId = this_thread::get_id();//获取当前执行线程的ID
    if(id==this_thread::get_id()){
        cout<<curId<<"hello main thread\n";
    }else{
        cout<<curId<<"hello work thread\n";
    }
    double v=0;
    for(auto iter = iterBegin;iter!=iterEnd;++iter){
        v+=func(*iter);
    }
    return v;
}

int main(){
    auto mainThreadId = this_thread::get_id();

    //开启一个单线程
    vector<double> v;
    for(int i=0;i<1000;i++){
        v.push_back(rand());
    }
    cout<<v.size()<<endl;
    double value = 0.0;
    auto st = clock();  //需要包含什么头文件？
    for(auto & info:v){
        value += caculate(info);
    }
    auto ed = clock();
    cout<<"single thread: "<<value<<" "<<ed-st<<"time"<<endl;

    //下面使用多线程实现
    auto iterMid = v.begin() +(v.size()/2);
    //计算后半部分
    double anotherV = 0.0;
    auto iterEnd =v.end();
    st = clock();

    thread s([&anotherV,mainThreadId,iterMid,iterEnd](){
        anotherV = visitRange(mainThreadId,iterMid,iterEnd,caculate);
    });
    //计算前半部分
    auto halfv = visitRange(mainThreadId,v.begin(),iterMid,caculate);
    //关闭线程
    s.join();

    ed = clock();
    cout<<"multi thread: "<<(halfv+anotherV)<<" "<<ed-st <<"time"<<endl;

    return 0;
}

执行结果：

1000
single thread: 120540 10623time
1hello main thread
2hello work thread
multi thread: 120540 5343time

二、多线程遇到的问题

共享变量带来的问题：

#include <iostream>
#include <thread>
#include <vector>
#include <cstdlib>
using namespace std;

class Counter{
public:
    void addCount(){
        m_count++;
    }
    int count() const{ return m_count;} //使用const修饰成员函数，常用在返回值这里
    Counter():m_count(0){ } //提倡的初始化方式，值的初始化在构造函数执行
private:
    int m_count;
};
int work(int a){
    return a+a;
}

template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.addCount(); //计数。
    }
}

int main(){
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

    //单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

    //多线程实现
    totalValue =0;
    Counter counter2;
    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
    //线程b负责计算1/3~2/3的工作
    thread b([&counter2,&totalValue,iter,iter2](){
        realWork(counter2,totalValue,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    thread c([&counter2,&totalValue,iter2,end](){
        realWork(counter2,totalValue,iter2,end);
    });

    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);

    b.join();
    c.join();
    cout<<"total times use multithread: "<<counter2.count()<<" "<<totalValue<<endl;

    return 0;
}

执行结果：

4 concurret thread are support.
total times: 10000000 9.89328e+008
total times use multithread: 4833168 4.61286e+008

可以发现两次的运算的结果不一致，因为三个线程共享一份资源，出现了重复对同一个数值相加的情况，例如：main、b、c都
对m_count=6加了一次，结果最后结果只是7，这就是共享变量的问题所在

解决方法：
1、不共享变量totalvalue

#include <iostream>
#include <thread>
#include <vector>
#include <cstdlib>
using namespace std;

class Counter{
public:
    void addCount(){
        m_count++;
    }
    int count() const{ return m_count;} //使用const修饰成员函数，常用在返回值这里
    Counter():m_count(0){ } //提倡的初始化方式，值的初始化在构造函数执行
private:
    int m_count;
};
int work(int a){
    return a+a;
}
template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.addCount(); //计数。
    }
}

int main(){
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

    //单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

    //多线程实现
    totalValue =0;
    Counter counter2;
    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
    //线程b负责计算1/3~2/3的工作
    double totalb = 0;   //每一个线程有自己的计数空间
    thread b([&counter2,&totalb,iter,iter2](){
        realWork(counter2,totalb,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    double totalc = 0;
    thread c([&counter2,&totalc,iter2,end](){
        realWork(counter2,totalc,iter2,end);
    });

    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);

    b.join();
    c.join();
    cout<<"total times use multithread: "<<counter2.count()<<" "<<totalValue+totalb+totalc<<endl;

    return 0;
}

执行结果：

4 concurret thread are support.
total times: 10000000 9.89328e+008
total times use multithread: 4307691 9.89328e+008

2、添加原子性

方法2；原子操作变量类型（复杂，适合简单的应用）
/b,c 线程共享了变量 counter2, 没有共享变量 totalValue，所以totalValue一样，counter2.count()不一样
count++： 写入寄存器，寄存器+1，写入内存
average()函数功能是如果Counter2不等于10000000，程序就不退出，如运行截图，由于共享变量counter2, 导致counter2总是无法等于10000000
解决：原子操作变量
只需要把int m_count; 改成 atomic m_count; 即可/

#include <iostream>
#include <thread>
#include <vector>
#include <cstdlib>
#include <string>
#include <atomic>  //添加头文件
using namespace std;

class Counter{
public:
    void addCount(){
        m_count++;
    }
    int count() const{ return m_count;} //使用const修饰成员函数，常用在返回值这里
    Counter():m_count(0){ } //提倡的初始化方式，值的初始化在构造函数执行
private:
//    int m_count;
    atomic<int> m_count;   //限制为原子操作
};
int work(int a){
    return a+a;
}
template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.addCount(); //计数。
    }
}
bool average(Counter& c,int maxCount){
    auto cnt = c.count();
    if(cnt == maxCount){
        cout<<" ok finished\n";
        return true;
    }
    return false;
}

int main(){
    //(1)如果没有必要的话，线程间不要共享资源
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

//    单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

//    多线程实现
    totalValue =0;
    Counter counter2;
    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
//    b,c线程共享了变量counter2，没有共享totalvalue，所以最后结果totalvalue一样，counter不一样
    //线程b负责计算1/3~2/3的工作
    double totalb = 0;   //每一个线程有自己的计数空间
    thread b([&counter2,&totalb,iter,iter2](){
        realWork(counter2,totalb,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    double totalc = 0;
    thread c([&counter2,&totalc,iter2,end](){
        realWork(counter2,totalc,iter2,end);
    });
    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);
    b.join();
    c.join();
    cout<<"total times use multithread: "<<counter2.count()<<" "<<totalValue+totalb+totalc<<endl;

    return 0;
}

执行结果：

 4 concurret thread are support.
total times: 10000000 9.89328e+008
total times use multithread: 10000000 9.89328e+008
//counter.count一致了

三、多线程操作多个变量

//=新增变量的处理，使用mutex互斥==========
核心部分：
void lockMutex() { m_mutex.lock(); }
void unlockMutex() { m_mutex.unlock(); }
使用：
c.lockMutex();
c.addCount();
c.addResource(1);
c.unlockMutex();
note：注意临界区的使用，否则可能会发生死锁

#include <thread>
#include <vector>
#include <cstdlib>
#include <string>
#include <atomic>
#include <mutex>
using namespace std;

class Counter{
public:
    void addCount(){
        m_count++;
    }
    int count() const{ return m_count;} //使用const修饰成员函数，常用在返回值这里
    Counter():m_count(0){ } //提倡的初始化方式，值的初始化在构造函数执行
    void addResource(int a){
        m_totalResource++;
    }
    int aveResource(){
        if(m_count==0)
            return 1;
        return m_totalResource/m_count;
    }
    void lockMutex(){ m_mutex.lock();}
    void unlockMutex(){ m_mutex.unlock();}
private:
//    int m_count;
    atomic<int> m_count;
    atomic<int> m_totalResource;
    mutex m_mutex;
};
int work(int a){
    return a+a;
}
template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.lockMutex();
        c.addCount(); //计数。
        c.addResource(1);
        c.unlockMutex();
    }
}

bool average(Counter& c,int maxCount){
    auto cnt = c.count();

    //需要上锁的操作
    c.lockMutex();
    auto ave = c.aveResource();
    if(ave !=1) cout<<"has bad thing happened\n";
    c.unlockMutex();

    if(cnt == maxCount){
        cout<<" ok finished\n";
        return true;
    }
    return false;
}

int main(){
    //(1)如果没有必要的话，线程间不要共享资源
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

//    单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

//    多线程实现
    totalValue =0;
    Counter counter2;
    thread printCount([&counter2](){
        while(!average(counter2,10000000)){ }
    });

    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
//    b,c线程共享了变量counter2，没有共享totalvalue，所以最后结果totalvalue一样，counter不一样
    //线程b负责计算1/3~2/3的工作
    double totalb = 0;   //每一个线程有自己的计数空间
    thread b([&counter2,&totalb,iter,iter2](){
        realWork(counter2,totalb,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    double totalc = 0;
    thread c([&counter2,&totalc,iter2,end](){
        realWork(counter2,totalc,iter2,end);
    });
    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);
    b.join();
    c.join();
//    cout<<"total times use multithread: "<<counter2.count()<<" "<<totalValue+totalb+totalc<<endl;

    auto realTotalCount = counter2.count();

    totalValue += totalb +totalc;
    cout<<"total times use multithread: "<<realTotalCount<<" "<<totalValue<<endl;

    printCount.join();

    return 0;
}
运行结果：
4 concurret thread are support.
total times: 10000000 9.89328e+008
 ok finished
total times use multithread: 10000000 9.89328e+008

四、把锁写到接口里

#include <iostream>
#include <thread>
#include <vector>
#include <cstdlib>
#include <string>
//#include <atomic>
#include <mutex>
using namespace std;

class Counter{
public:
    Counter():m_count(0),m_totalResource(0){ } //提倡的初始化方式，值的初始化在构造函数执行

    int count() const{  //添加const约束后，需要把mutex设置称为mutable类型
        m_mutex.lock();
        auto r =m_count;
        m_mutex.unlock();
        return r;
    }
    int aveResource(){
        m_mutex.lock();
        if(m_count==0){
            m_mutex.unlock();
            return 1;
        }
        auto r =m_totalResource/m_count;
        m_mutex.unlock();
        return r;
    }
    void addResourceAddCount(int r){
        m_mutex.lock();
        addCount();
        addResource(r);
        m_mutex.unlock();
    }

private:
//    int m_count;
//    atomic<int> m_count;
//    atomic<int> m_totalResource;
    void addResource(int a){
        m_totalResource++;
    }
    void addCount(){
        m_count++;
    }
    int m_count;
    int m_totalResource;
    mutable mutex m_mutex;
};
int work(int a){
    return a+a;
}
template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.addResourceAddCount(1);
    }
}

bool average(Counter& c,int maxCount){
    auto cnt = c.count();

    auto ave = c.aveResource();
    if(ave !=1) cout<<"has bad thing happened\n";
    if(cnt == maxCount){
        cout<<" ok finished\n";
        return true;
    }
    return false;
}

int main(){
 //(1)如果没有必要的话，线程间不要共享资源
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

//    单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

//    多线程实现
    totalValue =0;
    Counter counter2;
    thread printCount([&counter2](){
        while(!average(counter2,10000000)){ }
    });

    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
//    b,c线程共享了变量counter2，没有共享totalvalue，所以最后结果totalvalue一样，counter不一样
    //线程b负责计算1/3~2/3的工作
    double totalb = 0;   //每一个线程有自己的计数空间
    thread b([&counter2,&totalb,iter,iter2](){
        realWork(counter2,totalb,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    double totalc = 0;
    thread c([&counter2,&totalc,iter2,end](){
        realWork(counter2,totalc,iter2,end);
    });
    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);
    b.join();
    c.join();
//    cout<<"total times use multithread: "<<counter2.count()<<" "<<totalValue+totalb+totalc<<endl;

    auto realTotalCount = counter2.count();

    totalValue += totalb +totalc;
    cout<<"total times use multithread: "<<realTotalCount<<" "<<totalValue<<endl;

    printCount.join();

    return 0;
}
运行结果：
4 concurret thread are support.
total times: 10000000 9.89328e+008
 ok finished
total times use multithread: 10000000 9.89328e+008

五、自定义锁

原理：利用类对象使用完成后会自动调用析构函数，把上锁操作放在lock的构造函数中
释放锁操作放在lock的析构函数中，我们只用管定义，通过隐式调用构造和析构函数实现
我们想要的操作。

include <iostream>
#include <thread>
#include <vector>
#include <cstdlib>
#include <string>
//#include <atomic>
#include <mutex>
using namespace std;

template <typename T>
class Lock{
public:
    Lock(T& mutex):m_mutex(mutex){
        m_mutex.lock();
    }
    ~Lock(){
        m_mutex.unlock();
    }
private:
    T& m_mutex;
};

class Counter{
public:
    Counter():m_count(0),m_totalResource(0){ } //提倡的初始化方式，值的初始化在构造函数执行

    int count() const{  //添加const约束后，需要把mutex设置称为mutable类型
        Lock<mutex> lock(m_mutex);
        return m_count;
    }
    int aveResource(){
        Lock<mutex> lock(m_mutex);
        if(m_count==0){
            return 1;
        }
        return m_totalResource/m_count;
    }
    void addResourceAddCount(int r){
        Lock<mutex> lock(m_mutex);
        addCount();
        addResource(r);
//        m_mutex.unlock();  //为什么要这一句？不用的，博主的代码有错
    }
private:
//    int m_count;
//    atomic<int> m_count;
//    atomic<int> m_totalResource;
    void addResource(int a){
        m_totalResource++;
    }
    void addCount(){
        m_count++;
    }
    int m_count;
    int m_totalResource;
    mutable mutex m_mutex;
};
int work(int a){
    return a+a;
}
template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.addResourceAddCount(1);
    }
}

bool average(Counter& c,int maxCount){
    auto cnt = c.count();

    auto ave = c.aveResource();
    if(ave !=1) cout<<"has bad thing happened\n";
    if(cnt == maxCount){
        cout<<" ok finished\n";
        return true;
    }
    return false;
}

int main(){
    //(1)如果没有必要的话，线程间不要共享资源
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

//    单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

//    多线程实现
    totalValue =0;
    Counter counter2;
    thread printCount([&counter2](){
        while(!average(counter2,10000000)){ }
    });

    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
//    b,c线程共享了变量counter2，没有共享totalvalue，所以最后结果totalvalue一样，counter不一样
    //线程b负责计算1/3~2/3的工作
    double totalb = 0;   //每一个线程有自己的计数空间
    thread b([&counter2,&totalb,iter,iter2](){
        realWork(counter2,totalb,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    double totalc = 0;
    thread c([&counter2,&totalc,iter2,end](){
        realWork(counter2,totalc,iter2,end);
    });
    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);
    b.join();
    c.join();
//    cout<<"total times use multithread: "<<counter2.count()<<" "<<totalValue+totalb+totalc<<endl;

    auto realTotalCount = counter2.count();

    totalValue += totalb +totalc;
    cout<<"total times use multithread: "<<realTotalCount<<" "<<totalValue<<endl;

    printCount.join();

    return 0;
}
运行结果：
4 concurret thread are support.
total times: 10000000 9.89328e+008
 ok finished
total times use multithread: 10000000 9.89328e+008

六、使用STL的lock_guard

把上面自定义的lock换成lock_guard

#include <iostream>
#include <thread>
#include <vector>
#include <cstdlib>
#include <string>
//#include <atomic>
#include <mutex>
using namespace std;

class Counter{
public:
    Counter():m_count(0),m_totalResource(0){ } //提倡的初始化方式，值的初始化在构造函数执行

    int count() const{  //添加const约束后，需要把mutex设置称为mutable类型
        lock_guard<mutex> lock(m_mutex);
        return m_count;
    }
    int aveResource(){
        lock_guard<mutex> lock(m_mutex);
        if(m_count==0){
            return 1;
        }
        return m_totalResource/m_count;
    }
    void addResourceAddCount(int r){
        lock_guard<mutex> lock(m_mutex);
        addCount();
        addResource(r);
    }
private:
    void addResource(int a){
        m_totalResource++;
    }
    void addCount(){
        m_count++;
    }
    int m_count;
    int m_totalResource;
    mutable mutex m_mutex;
};
int work(int a){
    return a+a;
}
template <class Iter>
void realWork(Counter& c,double &totalValue,Iter b,Iter e){
    for(;b!=e;++b){
        totalValue +=work(*b);
        c.addResourceAddCount(1);
    }
}

bool average(Counter& c,int maxCount){
    auto cnt = c.count();

    auto ave = c.aveResource();
    if(ave !=1) cout<<"has bad thing happened\n";
    if(cnt == maxCount){
        cout<<" ok finished\n";
        return true;
    }
    return false;
}

int main(){
    //(1)如果没有必要的话，线程间不要共享资源
    unsigned n = thread::hardware_concurrency();  //检测硬件并发
    cout<<n<<" concurret thread are support.\n";

//    单线程实现
    vector<int> vec;
    double totalValue =0;
    for(int i=0;i<10000000;i++){
        vec.push_back(rand()%100);  //放入1~100的随机数
    }
    Counter counter;
    realWork(counter,totalValue,vec.begin(),vec.end());
    cout<<"total times: "<<counter.count()<<" "<<totalValue<<endl;

//    多线程实现
    totalValue =0;
    Counter counter2;
    thread printCount([&counter2](){
        while(!average(counter2,10000000)){ }
    });

    auto iter = vec.begin()+(vec.size()/3);
    auto iter2 = vec.begin()+(vec.size()/3*2);
//    b,c线程共享了变量counter2，没有共享totalvalue，所以最后结果totalvalue一样，counter不一样
    //线程b负责计算1/3~2/3的工作
    double totalb = 0;   //每一个线程有自己的计数空间
    thread b([&counter2,&totalb,iter,iter2](){
        realWork(counter2,totalb,iter,iter2);
    });
    auto end = vec.end();
    //线程c负责计算2/3~end的工作
    double totalc = 0;
    thread c([&counter2,&totalc,iter2,end](){
        realWork(counter2,totalc,iter2,end);
    });
    //main线程计算前1/3的工作
    realWork(counter2,totalValue,vec.begin(),iter);
    b.join();
    c.join();

    auto realTotalCount = counter2.count();
    totalValue += totalb +totalc;
    cout<<"total times use multithread: "<<realTotalCount<<" "<<totalValue<<endl;

    printCount.join();

    return 0;
}
TMAIAM
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 智能指针最佳实践&源码分析
腾讯技术工程
12-20 1428
作者：lucasfan，腾讯 IEG Global Pub.Tech. 客户端工程师智能指针在 C++11 标准中被引入真正标准库（C++98 中引入的 auto_ptr 存在较多问题），...
C++11线程池
未来之歌
03-31 524
纯C++11线程池，简单功能，无优先级设置等高级功能 参考代码： https://github.com/progschj/ThreadPool // ThreadPool.h #pragma once #ifndef THREAD_POOL_H #define THREAD_POOL_H #include &lt;vector&gt; #include &lt;queue&gt; #...
c++ 11 线程池---完全使用c++ 11新特性【转】
AuroraFaye的博客
03-16 713
前言： 目前网上的c++线程池资源多是使用老版本或者使用系统接口实现，使用c++ 11新特性的不多，最近研究了一下，实现一个简单版本，可实现任意任意参数函数的调用以及获得返回值。 0 前置知识 首先介绍一下用到的c++新特性 可变参数模板：利用这一特性实现任意参数的传递 bind函数，lambda表达式： 用于将带参数的函数封装为不带形参和无返回值的函数，统一接口 forward: 完美转发，防止在函数封装绑定时改变形参的原始属性（引用，常量等属性） shared_ptr, uniqu
C++ 多线程(3)std::thread 详解
热门推荐
一抹烟霞的博客
05-30 1万+
文章目录一、头文件二、std::thread 构造函数三、其他成员函数四、传递临时参数作为线程对象的注意事项4.1 **解决办法：**4.2 原因分析4.3 总结五、传递类对象、智能指针作为线程参数5.1 修改子线程中的对象，不会影响主线程中的对象5.2 传递智能指针参考链接： 一、头文件 std::thread 在 头文件中声明，因此使用 std::thread 时需要包含 头文件。 二、std::thread 构造函数 (1). 默认构造函数，创建一个空的 thread 执行对象。 (2). 初始
C++11 多线程（std::thread）详解
最新发布
az44yao的专栏
01-07 831
多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。
C++ thread学习一（利用C++11 thread创建线程）
mcc12356的博客
06-01 1215
之前几次学习多线程但都没有学到最后，今天重启C++多线程学习计划，希望可以坚持到最后。首先简单介绍一下进程以及线程。进程是系统资源分配的最小单位，线程是cpu执行的最小单位。简单来说，一个可执行程序运行起来就是一个进程，一个进程可能包含多个线程，一个进程一定有一个主线程，就相当于main函数，是程序的入口。 1. 创建一个线程 #include <iostream> using namespace std; #include "thread" void threadTest() {
c++ 多线程 类成员函数_C++11并发编程：多线程std::thread
weixin_39757040的博客
11-23 1267
一：概述C++11引入了thread类，大大降低了多线程使用的复杂度，原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需使用语言层面的thread可以解决这个问题。所需头文件< thread >二：构造函数1.默认构造函数thread() noexcept一个空的std::thread执行对象2.初始化构...
C++多线程编程实战 _C++_线程进程_thread_
10-03
P303.zip
在C++中使用openmp进行多线程编程
01-27
对于C++而言，当我们需要使用多线程时，可以使用boost::thread库或者自从C++ 11开始支持的std::thread，也可以使用操作系统相关的线程API，如在Linux上，可以使用pthread库。除此之外，还可以使用omp来使用多线程。...
C++多线程封装成类使用示例
12-19
C++11标准引入了内置的`<thread>`库，使得多线程编程变得更加简单。本示例将详细介绍如何将C++的多线程功能封装成一个类，以便在实际项目中更加灵活地使用。 首先，我们需要了解C++11中的`std::thread`类。`std::...
多线程编程之future库使用
03-26
c++11多线程编程库中的future库的使用实例，供多线程编程参考学习
线程示例WorkerThread_demo
07-09
线程示例WorkerThread_demo，线程示例WorkerThread_demo， 线程示例WorkerThread_demo，
C++多线程编程视频教程（C++11多线程并发）
06-09
线程与进程相比，它是一种花销小，...多编程并发在企业中开发显得尤为重要，本课程包含Windows多线程编程与C++11高并发编程，通过浅显易懂的代码与讲解，让你的多线程编程能力得到质的飞跃，具备开发高并发代码的能力!
c++多线程编程的十个例子
08-21
以下是对“C++多线程编程的十个例子”的详细讲解，这些例子将帮助你在Windows环境下深入理解和应用多线程。 1. **创建线程** C++11引入了`std::thread`库来创建和管理线程。例如，你可以通过传递函数或成员函数...
如何使用C++实现一个线程池（C++11标准）
hallobike的博客
04-20 2309
为了任务得到及时的处理（所谓任务可以理解为待执行的函数），把待处理的任务都放入线程池的任务队列中，线程池的多个线程就可以从该任务队列中取出任务并执行，线程再取出任务的同时，用户也可以向任务队列中添加新的任务，就好像用户只管把要执行的任务告诉线程池，线程池内部线程处理完成后返回用户处理结果。大致原理如下图。有读者可能疑问，函数不是调用了就执行了吗，怎么还可以放入什么任务队列？
windows编程 使用C++实现多线程类
皇天霸的博客
05-07 5686
本文简单介绍如何在windows编程中实现多线程类，供大家学习参考，也希望大家指正。 有时候我们想在一个类中实现多线程，主线程在某些时刻获得数据，可以“通知”子线程去处理，然后把结果返回。 下面的实例是主线程每隔2s产生10个随机数，将这10随机数传给多线程类，让它接收到数据后马上打印出来。 首先看类的定义： #pragma once #include #include
C++11 thread库 用法举例
CN_BIT的博客
03-11 353
join()和detach() #include "pch.h" #include <iostream> #include <thread> #include <string> #include <chrono> #include <sstream> #include <ctime> #include <iomanip> using namespace std; void print_time() { auto n
C++多线程之线程类thread
喜欢打篮球的普通人
05-26 4322
文章目录1.简介2.构造函数3.公共成员函数4.join()5.detach()6.joinable()6.operator=7.静态函数8.C线程库 1.简介 C++11 中提供的线程类叫做 std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象即可，并且可以同时指定线程函数的参数 2.构造函数 这个类提供的一些常用 API // ① //构造函数①：默认构造函，构造一个线程对象，在这个线程中不执行任何处理动作 thread() noexcept; // ② /
C++ 并行编程(thread)---多线程
泠山的博客
10-31 1万+
进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。是程序执行的最小单位。
C++11并发与多线程编程实战指南
"《C++并发编程(中文版)》基于C++11新标准，深入探讨了并发和多线程编程，由Anthony Williams著，适用于C++开发者、测试...通过阅读本书，读者将能够写出高效、安全的多线程C++应用程序，以适应多核时代的编程需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值