C++11 多线程并发编程,thread，lock,lock_guard，unique_lock使用

最新推荐文章于 2024-04-10 21:59:10 发布
最新推荐文章于 2024-04-10 21:59:10 发布
阅读量1k 收藏 1
点赞数
文章标签： 多线程 C++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33312412/article/details/102832362
版权

0、thread的成员函数

myjob.join();//阻塞主线程，使得子线程执行完毕之后再执行主线程。
myjob.detach();//解除主线程与子线程的关系，两者独立执行，主线程执行完毕后会自动退出。

joinable();//用于检测线程是否joinable

joinable ： 代表该线程是可执行线程。

not-joinable ：通常一下几种情况会导致线程成为not-joinable

 1） 由thread的缺省构造函数构造而成(thread()没有参数)。

 2） 该thread被move过（包括move构造和move赋值）

 3） 该线程调用过join或者detach

detach方式下注意事项：

（1）detach()方式时，传指针如果主线程先执行完会发生错误，引用会拷贝不推荐使用。
（2）传递简单数据类型，建议值传递代替引用
（3）传递类对象，避免隐式类型转换，创建线程时使用显示类型转换，并且类对象中函数使用引用。
	//std::ref(A)作用：线程传对象时传递参数对象，不进行另外的拷贝

	//cout<<"main thread id is : "<<std::this_thread::get_id() << endl;//获取线程id

1、互斥量mutex类中有lock() 和unlock()函数、存在多个锁时，加锁顺序一致以防死锁
2、std::lock_guard为类模板，可以取代lock、unlock,可以自己释放锁
//lock_guard构造时调用lock()，析构时调用unlock()
3、std::lock(),锁住两个及两个以上的互斥量。一次加所有锁，要么全加锁要么不加锁。不存在加锁顺序导致死锁的问题
//示例：lock(mutex1,mutex2,…);
4、std::lock_guard()与std::lock()结合使用
//示例：
//std::lock(mutex1,mutex2);
//std::lock_guard guard(mutex1,std::adopt_lock);//使用adpot_lock参数，其为结构体对象
//std::lock_guard guard(mutex2,std::adopt_lock);//使用adpot_lock参数

5、unique_lock是类模板，比lock_guard()更灵活,效率相对低，内存占用高
5.1 初始化参数 adopt_lock(需要提前lock) adpot_lock参数使得构造时不调用mutex的lock函数
示例:

mutex1.lock();   
unique_lock<mutex> guard(mutex1,std::adopt_lock);

5.2 初始化参数std::try_to_lock 在构造unique_lock时尝试加锁,加锁失败则返回，不会阻塞。使用时不能提前加锁
5.3 初始化参数std::defer_lock初始化没有加锁的mutex

6、unique_lock 成员函数
6.1 lock() 不用自己unlock()
6.2 unlock() 用户灵活解锁
6.3 bool try_lock() 尝试加非阻塞锁，加锁成功返回true,加锁失败返回false
6.4 release(),返回它所管理的mutex对象指针，并释放其所有权。解除mutex与unique_lock的联系
7、unique_lock的所有权传递,unique_lock的mutex可以转移，不能复制
//两个unique_lock间转移mutex所有权： unique_lock2(std::move(unique_lock1))
// 通过其他函数返回的unique_lock对象初始化 :

std::unique_lock<std::mutex> unique_lock2 = return_lock()//return_lock 返回另一个unique_lock对象

8、sleep 一些毫秒

std::chrono::milliseconds dura(2000);//2秒
std::this_thread::sleep_for(dura);//休息2秒

9、代码Demo

   #include <iostream>
    #include <thread>
    #include <vector>
    #include <queue>
    #include <mutex>
    
    using namespace std;
    
    
    void myprint(const int &i, char* pmybuf)
    {
    	cout << i << endl;
    	cout << "main thread id is : " << std::this_thread::get_id() << endl;
    	cout << pmybuf << endl;
    }
    class A
    {
    public:
    	int val;
    	A(int s):val(s)
    	{
    		cout << "构造" << endl;
    	}
    	~A()
    	{
    		cout << "析构" << endl;
    	}
    	void print(int num)
    	{
    		cout << "print num is :" << num << endl;
    	}
    };
    
    class B
    {
    private:
    	queue<int> que;
    	mutex my_mymutex;//互斥量
    private:
    	//删除元素
    	bool popCore(int &num)
    	{
    		my_mymutex.lock();//加锁
    		if (!que.empty())
    		{
    			num = que.front();
    			que.pop();
    			my_mymutex.unlock();//解锁
    			return true;
    		}
    		my_mymutex.unlock();//解锁
    		return false;
    	}
    	bool popCore2(int &num)
    	{
    		//std::lock_guard<mutex> guard(my_mymutex);//使用lock_guard
    		std::unique_lock<std::mutex> guard(my_mymutex);//使用unique_lock
    		
    		std::chrono::milliseconds dura(2000);//2秒
    		std::this_thread::sleep_for(dura);//休息2秒
    
    		if (!que.empty())
    		{
    			num = que.front();
    			que.pop();
    			return true;
    		}
    		return false;
    	}
    public:
    	//插入元素
    	void insert()
    	{
    		for (int i = 0; i < 1000; i++)
    		{
    			cout << "插入元素 i: " << i << endl;
    			std::unique_lock<std::mutex> guard(my_mymutex, std::try_to_lock);//使用unique_lock
    			
    			if (guard.owns_lock())
    			{
    				cout << "加锁成功" << endl;
    				que.push(i);
    			}
    			else
    				cout << "加锁失败" << endl;
    		}
    	}
    	//删除元素对外接口
    	void pop()
    	{
    		int num;
    		for (int i = 0; i < 1000; i++)
    		{
    			if (popCore2(num))
    				cout << "出队 数字 num :"<< num << endl;
    			else
    				cout << "que is NULL" << endl;
    		}
    	}
    };
    
    int main()
    { 
        /*
    	int num =10;
    	char[] buf = "this is a buf";
     	thread myjob(myprint,num,buf);//可调用函数、对象等，myprint为可调用函数,有参数的话后跟其参数
    
    	if (myjob.joinable())
    		cout << "join true1" << endl;
    	else
    		cout << "join false1" << endl;
    	myjob.join();//阻塞主线程，使得子线程执行完毕之后再执行主线程。
    	*/
    
    	/*  lamada表达式作为线程执行对象
    	auto mylamdathread = [] {
    		cout << "lamda thread bgein" << endl;
    		cout << "lamda thread end" << endl;
    	};
    	thread myjob2(mylamdathread);
    	myjob2.join();
    	cout << "hello" << endl;
    	*/
    
    	/*类成员函数指针做线程执行对象
    	A myobj(10);
    	thread myjob4(&A::print,myobj,20);
    	myjob4.join();
    	*/
    
    	/*创建多个线程，各子线程之间顺序靠操作系统调度
    	vector<thread> threads;
    	for (int i = 0; i < 10; i++)
    		threads.push_back(thread(print,i));
    
    	for (auto it = threads.begin(); it != threads.end(); ++it)
    		it->join();
    	*/
    
    	B b;
    	thread insert_thread(&B::insert, &b);
    	thread pop_thread(&B::pop, &b);
    	insert_thread.join();
    	pop_thread.join();
    	cout << "hello" << endl;
    	
    	return 0;
    }

条件变量condition_variable、wait、notify_one、notify_all

 #include <iostream>
    #include <thread>
    #include <vector>
    #include <queue>
    #include <mutex>
    
    using namespace std;
    
    class B
    {
    private:
    	queue<int> que;
    	mutex my_mymutex;//互斥量
    	std::condition_variable my_cond;//条件变量
    public:
    	//插入元素
    	void insert()
    	{
    		for (int i = 0; i < 1000; i++)
    		{
    			
    			std::unique_lock<std::mutex> guard(my_mymutex);//使用unique_lock
    			cout << "插入元素 i: " << i << endl;
    			que.push(i);
    			my_cond.notify_one();//通知一个线程唤醒wait的线程
    								 //notify_all()通知所有线程唤醒wait的线程,唤醒的多个线程争用锁
    
    		}
    	}
    	//删除元素对外接口
    	void pop()
    	{
    		int num = 0;
    		while (true)
    		{
    			std::unique_lock<std::mutex> guard(my_mymutex);
    			//wait()没有第二个参数或第二个参数返回false则解锁互斥量，阻塞；直到其他线程调用notify_one()函数
    			my_cond.wait(guard, [this] {//lambda表达式
    				if (!que.empty())
    					return true;
    				return false;
    			});
    			num = que.front();
    			que.pop();
    			guard.unlock();//灵活释放锁，可由unique_lock对象析构时释放
    			cout << "出队元素为：" <<num << endl;
    		}
    	}
    };
    
    int main()
    {
    	B b;
    	thread insert_thread(&B::insert, &b);
    	thread pop_thread(&B::pop, &b);
    	insert_thread.join();
    	pop_thread.join();
    	cout << "hello" << endl;
    
    	return 0;
    }

原子操作、std::async()使用

1、std::async为函数模板，返回std::future类对象 作用为创建异步任务

(1)参数std::launch::deferred表示任务等待get()或wait()时执行，延迟调用，不创建线程，主线程中执行
	示例：std::future<int> result = std::async(std::launch::deferred，mythread)
(2)参数std::launch::async调用async()时创建执行子线程异步执行
(3)std::launch::async | std::launch::deferred，首先创建新线程异步执行，创建失败时则延迟主线程执行

2、std::packaged_task 打包任务，类模板
示例：std::packaged_task<int(int)> mypt(mythread);

3、std::promise类模板,在某个线程中给它赋值，其他线程中可以使用

4、std::future result = std::async(mythread,10);

  std::future_status status = result.wait_for(std::chrono::seconds(1));//等待1s返回枚举类型

std::future_status：

（1）ready ，线程执行完毕

（2）timeout，超时，线程未执行完毕

（3）deferred，async的第一个参数设置为std::launch::deferred，由主线程延迟执行

5、可以定义为原子操作的运算符：++、–、+=、-=，&=、|=等

//定义全局变量
std::atomic<int> num;//原子操作对象

（1）atomic的load()函数以原子方式读 auto num2 (num.load());

（2）atomic的store()函数以原子方式写 num2.store(123);

 #include <iostream>
    #include <thread>
    #include <vector>
    #include <queue>
    #include <mutex>
    #include <future>
    using namespace std;
    
    //全局变量
    std::atomic<int> num;//原子操作对象
    
    int mythread(int num)
    {
    	cout << "thread begin, thread id is :" << std::this_thread::get_id() << endl;
    	std::chrono::milliseconds dura(2000);//休息2秒
    	std::this_thread::sleep_for(dura);
    	cout << "thread end" << endl;
    	return 5;
    }
    //promise类模板使用，在某个线程中给它赋值，其他线程中可以使用
    void func(std::promise<int> &temp, int calc)
    {
    	calc++;
    	calc *= 10;
    	std::chrono::milliseconds dura(2000);//休息5秒
    	std::this_thread::sleep_for(dura);
    	int result = calc;
    	temp.set_value(result);
    }
    
    //原子操作演示
    void addNum()
    {
    	for (int i = 0; i < 1000; i++)
    		num++;//atomic对象的操作是原子操作
    }
    
    int main()
    {
    	int num = 3;
    	cout << "main thread id is :" << std::this_thread::get_id() << endl;
    	
    	//1、std::async为函数模板，返回std::future类对象  作用为创建异步任务
    	std::future<int> result = std::async(mythread,num);//以mythread()为执行对象创建一个后台线程，此时不会阻塞
    	//std::future<int> result = std::async(mythread);//async(&A::func,&a,参数)，
    													//A类的成员函数func做执行对象，a为A的对象，参数为func的参数
    	//2、(1)参数std::launch::deferred表示任务等待get()或wait()时执行
    		//延迟调用，不创建线程，主线程中执行
    		//示例：std::future<int> result = std::async(std::launch::deferred，mythread)
    		//(2)参数std::launch::async调用async()时创建执行子线程
    		//(3)std::launch::async | std::launch::deferred，首先创建新线程异步执行，创建失败时则延迟主线程执行
    
    	cout << result.get() << endl;//阻塞直到result返回结果，get函数只能调用一次
    	cout << "结束" << endl;
    	
    
    	/*
    	//3、std::packaged_task 打包任务，类模板
    		//std::packaged_task<int(int)> mypt(mythread);
    	std::packaged_task<int(int)> mypt([](int num) {//包装lambda表达式
    		cout << "thread begin, thread id is :" << std::this_thread::get_id() << endl;
    		std::chrono::milliseconds dura(1000);//休息1秒
    		std::this_thread::sleep_for(dura);
    		cout << "thread end" << endl;
    		return 5; 
    	});
    	std::thread t1(std::ref(mypt), 1);
    	t1.join();
    	std::future<int> result = mypt.get_future();
    
    	cout << result.get() << endl;
    	*/
    
    	/*
    	//std::promise类模板,在某个线程中给它赋值，其他线程中可以使用
    	std::promise<int> myprom;
    	std::thread t1(func,std::ref(myprom), 10);
    	t1.join();
    	std::future<int> result = myprom.get_future();
    	auto res = result.get();
    	cout << "result : " << res << endl;
    	cout << "结束" << endl;
    	*/
    
    
    	/*
    	//4、
    	std::future<int> result = std::async(mythread,10);
    	std::future_status status = result.wait_for(std::chrono::seconds(1));//等待1s返回枚举类型
    	if (status == std::future_status::timeout)//表示超时，线程未执行完
    	{
    		cout << "超时，线程未执行完" << endl;
    	}
    	else if (status == std::future_status::ready)//表示线程成功返回
    	{
    		cout << "线程执行完毕，返回" << endl;
    		cout << result.get() << endl;
    	}
    	else if (status == std::future_status::deferred)
    	{
    		//async的第一个参数设置为std::launch::deferred
    		cout << "线程延迟执行" << endl;
    		cout << result.get() << endl;
    	}
    	*/
    
    	/*
    	//5、shard_future 类模板,get()复制数据,可以get多次
    	std::packaged_task<int(int)> mypt(mythread);
    	std::thread t1(std::ref(mypt), 10);
    	t1.join();
    
    	std::future<int> result = mypt.get_future();
    	bool isValid = result.valid();
    	if(isValid)
    		cout<<"result valid"<<endl;
    	std::shared_future<int> shared_res(result.share()); //等价于std::move(result)
    	//上述5行可以代替为:
    		//std::shared_future <int > res(mypt.get_future());
    		
    	isValid = result.valid();
    	if (!isValid)
    	{
    		cout << "result unvalid" << endl;
    		isValid = shared_res.valid();
    		cout << "get result :" << shared_res.get() << endl;
    		cout << "get result :" << shared_res.get() << endl;
    		cout << "get result :" << shared_res.get() << endl;
    	}
    	*/
    
    	/*
    	//6、原子操作std::atomic
    		//全局变量num定义为atomic对象
    	thread t1(addNum);
    	thread t2(addNum);
    	t1.join();
    	t2.join();
    	cout << num << endl;
    	*/
    	return 0;
    }
阿苏丶丶丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 多线程编程(二):threading 模块中 Lock 类的用法详解
frank 的专栏
12-23 3万+
在前面一篇博文《Python多线程编程(一）：threading 模块 Thread 类的用法详解 》 我有简单介绍怎么利用 threading 模块进行多线程的编码。 但那只是多线程编码最简单的部分，真正难的其实是多个线程之间的通信和数据同步。 大概可以这样讲，多线程最难的是如何正确协调各个线程修改同一份数据。 以卖票的例子作为说明。 买票有多个窗口，假设有 3 个好了，窗口之间共享一个票池，每...
Thread lock_guard 和 unique_lock
zheng2263的博客
12-02 374
#include "stdafx.h" #include #include #include int i; std::mutex i_mutex; struct Box { explicit Box(int num) : num_things{ num } {} int num_things; std::mutex m; }; void safe_increment() {
【多线程】c++11多线程编程(五)——unique_lock和lock_guard
bandaoyu的note
05-13 445
互斥锁保证了线程间的同步，但是却将并行操作变成了串行操作，这对性能有很大的影响，所以我们要尽可能的减小锁定的区域，也就是使用细粒度锁。 这一点lock_guard做的不好，不够灵活，lock_guard只能保证在析构的时候执行解锁操作，lock_guard本身并没有提供加锁和解锁的接口，但是有些时候会有这种需求。看下面的例子。 class LogFile { std::mutex _mu; ofstream f; public: LogFile() { f.op
C++ Thread 死锁
XXXTENTAC1ON的博客
04-27 758
死锁死锁示例如何解决死锁 死锁示例 线程A与线程B陷入无休止的阻塞状态 std::mutex mx1; std::mutex mx2; void thread_func1() { unique_lock<std::mutex> lc1(mx1); cout << "1号锁" << endl; std::this_thread::sleep_for(std::chrono::microseconds(200)); unique_lock<std::mut
C/C++编程：thread库之锁的使用
OceanStar的博客
07-15 5586
mutex(互斥量)是一种线程同步手段，可以在多线程环境中防止多个线程同时操作共享资源。C++11起，标准库提供std::mutex以满足开发者对互斥锁的需求，相关的变体还有许多，如recursive_mutex，timed_mutex，shared_mutex等等。注意，mutex不可复制，不可移动(move)。
C++11 并发指南之多线程初探
12-20
C++11是C++语言的一个重要里程碑，它引入了许多新特性，特别是在并发编程领域，大大提升了C++作为多线程编程语言的能力。本篇文章将深入探讨C++11中的多线程支持。 在C++11之前，开发人员通常依赖于如POSIX的...
tcpcliserv.rar_C语言_c++ tcp 多线程_c++ tcp 多线程_tcp多线程_unix tcp
09-24
2. **C++中的线程库**：在C++11及其后续版本中，引入了`<thread>`库来支持多线程编程。使用`std::thread`可以创建新的线程，`std::mutex`和`std::lock_guard`用于线程同步，防止竞态条件。 3. **TCP服务器创建**：...
多线程并发编程参考资料
03-24
本文将深入探讨标题为"多线程并发编程参考资料"的宝典，重点关注C#和C++这两种开发语言中的相关知识。 1. **多线程基础**： - 线程是操作系统调度的基本单位，每个线程都有自己的执行上下文，可以独立于其他线程...
c++多线程写法与案例 c++多线程保存点云
09-01
在C++编程中，多线程技术是一种提升程序性能的有效手段，特别是在处理大量数据或并发操作时。在点云处理领域，多线程可以并行地读取、处理和保存数据，显著加快处理速度。本篇文章将深入探讨C++中的多线程实现，以及...
多线程
Alie1129的博客
03-11 484
多任务可以由多进程完成，也可以由一个进程内的多线程完成。 我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。 由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。 Python的标准库提供了两个模块：_thread和threading，_thre...
ThreadGuard
wangzhicheng2013的专栏
01-02 784
thread guard
Thread_Lock(线程锁)
suenpeng
08-02 3265
package com.gzhs.zsd.thread;import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;/** * Thread线程Lock测试 */ public class Thread_Lock {public static void main(Strin
C++11 thread lock 死锁解决方法
吸喵高手的小窝
04-19 733
#include <iostream> #include <mutex> #include <thread> using namespace std; class Account{ public: //when create is always true Account(const std::string& acountNam...
C++线程(thread)、锁(mutex)以及atmoic
shouhu010的博客
02-25 1030
线程 锁 互斥锁 定时锁 自旋锁 读写锁 递归锁 共享锁 原子操作
C++ 线程库(thread)与锁(mutex)
最新发布
Emilia_is_angel的博客
04-10 911
对C++11线程库与锁的简单介绍
c++多线程thread操作（四）死锁的问题和解决
BearLeer的博客
06-28 1344
1. 死锁问题的出现，出现了循环调用，并且抢占了资源。 class LofFile { private: mutex m_mutex1; mutex m_mutex2; public: LofFile() {} void shared_print(string msg, int id) { lock_guard<mutex> guard1(m_mutex1); lock_guard<mutex> guard2(m_mutex2); cout <<
Thread Guard
liugan528的博客
06-26 466
#include <thread> #include <iostream> class Stomach { public: void Dislike() { std::cout << "I can't stomach his speeches." << std::endl; } }; class ThreadGuard { public: ThreadGuard(std::thread &t) : t_(t)
C++11之线程库（Thread、Mutex、atomic、lock_guard、同步）
林夕07
06-28 1098
在C++ 11引入了对多线程的支持。包括线程、互斥锁、原子操作、自动加减锁和同步。下面就分别介绍一下对应的用法。线程：系统分配cup时间和调度的基本单位#includethread t1(函数地址)；//无参 thread t2(函数地址，参数1，参数2,…)；//有参A a; thread t3(&A::output,&a)；成员函数，全局函数实例： 成员函数实例： 多线程的冲突问题 a. 出现了更高等级的指令 b. 该线程的时间片到了#include 原子操作Atomic ...
线程（三）：Lock（互斥锁）、RLock（ 递归锁）、Semaphore（信号量）、Event（事件）、Condition（条件）、Timer（定时器）、queue（队列）
。
11-15 619
目录 一、锁 1）全局解释器锁GIL介绍 2）同步锁（互斥锁） 3）死锁与递归锁 二、信号量 三、事件 四、条件 五、定时器 六、线程队列 一、锁 1）全局解释器锁GIL介绍         首先需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成...
多线程编程详解：mutex、lock_guard与unique_lock
本文档是关于多线程编程的一个教程，由陶云峰编著，主要涵盖了在C++中使用多线程和相关同步机制的关键知识点。文档内容包括了如何创建和管理线程、使用互斥量、智能锁以及条件变量，同时还涉及到了异步执行和承诺/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值