C++多线程并发

#include <iostream>
#include <thread>
using namespace std;
void proc(int &a)
{
    cout<<"我是子线程，传入参数为"<<a<<endl;
    cout<<"子线程中显示子线程id为"<<this_thread::get_id()<<endl;
}
int main()
{
    cout<<"我是主线程"<<endl;
    int a = 9;
    thread th2(proc,ref(a));
    cout<<"主线程中显示子线程id为"<<th2.get_id()<<endl;
    //省略多行
    th2.join();
    return 0;
}

读写锁

#include <iostream>
#include <thread>
#include <shared_mutex>
using namespace std;
shared_mutex s_m;
string book;
void read(){
    s_m.lock_shared();
    cout<<book;
    s_m.unlock_shared();
}
void write(){
    s_m.lock();
    book = "new context";
    s_m.unlock();
}

lock()与unlock():

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
mutex m;//实例化对象，不要理解为定义变量
void proc1(int a){
    m.lock();
    cout<<"proc1函数正在改写a"<<endl;
    cout<<"原始a = "<<a<<endl;
    cout<<"现在a = "<<a+2<<endl;
    m.unlock();
}
void proc2(int a){
    m.lock();
    cout<<"proc2函数正在改写a"<<endl;
    cout<<"原始a = "<<a<<endl;
    cout<<"现在a = "<<a+1<<endl;
    m.unlock();
}
int main(){
    int a = 0;
    thread t1(proc1,a);
    thread t2(proc2,a);
    t1.join();
    t2.join();
    return 0;
}

lock_guard:

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
mutex m;
void proc1(int a){
    lock_guard<mutex> g1(m);//用此语句替换了m.lock();lock_guard传入一个参数时，该参数为互斥量，此时调用了lock_guard的构造函数，申请锁定m
    cout<<"proc1函数正在改写a"<<endl;
    cout<<"原始a = "<<a<<endl;
    cout<<"现在a = "<<a+2<<endl;
}//此时不需要写m.unlock(),g1出了作用域被释放，自动调用析构函数，于是m被解锁
void proc2(int a){
    {
        lock_guard<mutex> g2(m);
        cout<<"proc2函数正在改写a"<<endl;
        cout<<"原始a = "<<a<<endl;
        cout<<"现在a = "<<a+1<<endl;
    }//通过使用{}来调整作用域范围，可使得m在合适的地方被解锁
    cout<<"作用域外的内容3"<<endl;
    cout<<"作用域外的内容4"<<endl;
    cout<<"作用域外的内容5"<<endl;
}
int main(){
    int a = 0;
    thread t1(proc1,a);
    thread t2(proc2,a);
    t1.join();
    t2.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
mutex m;
void proc1(int a){
    m.lock();
    lock_guard<mutex> g1(m,adopt_lock);
    cout<<"proc1函数正在改写a"<<endl;
    cout<<"原始a = "<<a<<endl;
    cout<<"现在a = "<<a+2<<endl;
}//自动解锁
void proc2(int a){
    lock_guard<mutex> g2(m);
    cout<<"proc2函数正在改写a"<<endl;
    cout<<"原始a = "<<a<<endl;
    cout<<"现在a = "<<a+1<<endl;
}//自动解锁
int main(){
    int a = 0;
    thread t1(proc1,a);
    thread t2(proc2,a);
    t1.join();
    t2.join();
    return 0;
}

unique_lock:

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
mutex m;
void proc1(int a)
{
    unique_lock<mutex> g1(m,defer_lock);//初始化了一个没有加锁的mutex
    cout<<"***********************"<<endl;
    g1.lock();//手动加锁，注意不是m.lock(),m已经被g1接管了；
    cout<<"proc1函数正在改写a"<<endl;
    cout<<"原始a = "<<a<<endl;
    cout<<"现在a = "<<a+2<<endl;
    g1.unlock();//临时解锁
    cout<<"************"<<endl;
    g1.lock();
    cout<<"***"<<endl;
}//自动解锁
void proc2(int a)
{
    unique_lock<mutex> g2(m,try_to_lock);//尝试加锁一次，但如果没有锁定成功，不会阻塞在那里，且不会再次尝试锁操作
    if(g2.owns_lock())//锁成功
    {
        cout<<"proc2函数正在改写a"<<endl;
        cout<<"原始a = "<<a<<endl;
        cout<<"现在a = "<<a+1<<endl;
    }
    else//锁失败则执行这段语句
        cout<<" "<<endl;
}//自动解锁
int main()
{
    int a = 0;
    thread t1(proc1, a);
    t1.join();
    thread t2(proc2, a);
    t2.join();
    return 0;
}