c++：互斥锁/多线程的创建和unique_lock＜mutex＞的使用

1.多线程的创建

1）包括头文件

#include<thread>
#include<mutex>

2）新建线程
新建线程两个
使用thread 线程名来新建一个线程
并在线程中threadHello调用函数 void sayHello()
并在线程中threadWorld调用函数 void sayWorld()

//这里可以引入Windows头文件，然后使用Sleep()函数
#include <iostream>
#include<thread>
#include<unistd.h>
using namespace std;
void sayHello()
{
    while(1)
    {
        sleep(1);
        cout<<endl<<"hello"<<endl;
    }

}
void sayWorld()
{
    while(1)
    {
        sleep(1);
         cout<<endl<<"world"<<endl;
    }
}
int main()
{
   thread threadHello(&sayHello);
    thread threadWorld(&sayWorld);
     threadHello.join();
     threadWorld.join();

   return 0;
}

2.线程的同步(unique_lock的使用)
unique_lock中的unique表示独占所有权。
unique_lock独占的是mutex对象，就是对mutex锁的独占。
用法：
（1）新建一个unique_lock 对象
（2）给对象传入一个std::mutex 对象作为参数;
std::mutex mymutex;
unique_lock lock(mymutex);

因此加锁时新建一个对象lock
unique_lock lock(mymutex);
而这个对象生命周期结束后自动解锁。
如下例子

#include <iostream>
//#include<thread>
#include <windows.h>
#include<mutex>
using namespace std;
std::mutex mymutex;
void sayHello()
{
    int k = 0;
    //unique_lock<mutex> lock(mymutex);
    while (k < 5)
    {
        k++;
        cout << endl << "hello" << endl;
        Sleep(20);
    }
}
void sayWorld()
{
    //unique_lock<mutex> lock(mymutex);
    int k = 0;
    while (k < 5)
    {
        cout << endl << "world" << endl;
        k++;
        Sleep(20);
    }
}
int main()
{
    thread threadHello(&sayHello);
    thread threadWorld(&sayWorld);
    threadHello.join();
    threadWorld.join();
    return 0;
}

上面试没有加锁的情况，输出如下：

加锁后输出如下：

---

编辑历史

更新简介	更新日期	备注
新增下面代码内容，网上资料整理的例子，关于进程和互斥锁	2022年8月19日	NULL

 

#include<iostream>
#include<string>
#include<thread>
#include<mutex>
using namespace std;

//1.不安全线程，线程之间互相抢占资源，大概率会得到非预期结果

void f1() {
	cout << "线程id:" << this_thread::get_id() << endl;
}

//2.加互斥锁，保证线程安全。但是这种方式要手动释放锁，否则资源不会被释放
mutex m_lock;
void f2() 
{
	m_lock.lock();
	cout << "线程id:" << this_thread::get_id() << endl;
	m_lock.unlock();
}
//3.模板类，析构时自动释放，不能手动调用unlock()，否则析构时再次调用，会报异常。
void f3()
{
	lock_guard<mutex> auto_lock(m_lock);
	cout << "线程id:" << this_thread::get_id() << endl;
}

//4.和3类似，区别是
//lock_guard在创建获得锁之后必须要等到析构时才会释放锁，这样就造成其他线程在执行不涉及临界资源的代码时浪费了时间，大大降低效率。
//而unique_lock在创建获得锁之后可等到析构时才会释放锁，也可以手动释放锁，这样可以在执行不涉及临界资源的代码是解锁，提高效率。
void f4()
{
	unique_lock<mutex>  auto_lock(m_lock);
	cout << "线程id:" << this_thread::get_id() << endl;
}
int main()
{
	thread tTest1(f1);
	thread tTest2(f1);
	tTest1.join();
	tTest2.join();
	system("pause");
	return 0;
}