【c++11线程库的使用】

已于 2024-03-10 15:59:14 修改
阅读量1.2k 收藏 17
点赞数 27
文章标签： c++ 算法 开发语言 现代c++
于 2024-03-10 11:09:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59068776/article/details/136597586
版权

#include<iostream>
#include<thread>
#include<string>
using namespace std;
void hello(string msg) {
    for (int i = 0; i < 1000; i++) {
        cout << i;
        cout << endl;
    }
}
int main() {
    //1.创建线程
    thread thread1(hello,"hello Thread");//打印的就是hello Thread
    //主程序等待  看我这个程序运行完了吗
    //第三个知识点：thread1.join();//当上一个线程没有结束之前主线程是不会结束的
    //主线程结束之后我的线程依然可以再后台运行 那就是分离线程detach()
    //第四个知识点：thread1.detach();//这个就是主线程和子线程分离
    //第五个知识点：
    bool isJoin = thread1.joinable();//针对一个线程，可以调用detach,或者join。两者是互斥的关系，
    //也就说一旦调用了join，detach就不能再调用了，反之亦成立。
    //判断是否已经使用过join或者detach可以用joinable。
    if (isJoin) {
        thread1.join();
    }
    cout << "over" << endl;
    return 0;
}

std::ref传递引用类型

 #include<iostream>
 #include<thread>
 #include<string>
 using namespace std;
 void foo(int& x) {
     x += 1;
     
 }
 int main() {
     int a = 1;
     //thread t(foo, 1);//这个1不是引用是临时变量穿不进去  就释放掉了
     //所以要用ref  修饰这个a证明这个a就是它需要的引用变量
     thread t(foo, ref(a));
     t.join();
     cout << a << endl;
     return 0;
 }

类成员函数作为入口函数，类对象被提前释放

  错误示例：
 #include <iostream>
 #include <thread>
 ​
 class MyClass {
 public:
     void func() {
         std::cout << "Thread " << std::this_thread::get_id() 
         << " started" << std::endl;
         // do some work
         std::cout << "Thread " << std::this_thread::get_id() //线程的信息
         << " finished" << std::endl;
     }
 };
 ​
 int main() {
     MyClass obj;
     std::thread t(&MyClass::func, &obj);
     // obj 被提前销毁了，会导致未定义的行为
     return 0;
 }

上面的代码中，在创建线程之后，obj 对象立即被销毁了，这会导致在线程执行时无法访问 obj 对象，可能会导致程序崩溃或者产生未定义的行为。

为了避免这个问题，可以使用 std::shared_ptr 来管理类对象的生命周期，确保在线程执行期间对象不会被销毁。具体来说，可以在创建线程之前，将类对象的指针封装在一个 std::shared_ptr 对象中，并将其作为参数传递给线程。这样，在线程执行期间，即使类对象的所有者释放了其所有权，std::shared_ptr 仍然会保持对象的生命周期，直到线程结束。

 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 using namespace std;
 class A {
 public:
     void foo() {
         cout << "hello world" << endl;;
     }
 };
 int main() {
     shared_ptr<A> a = make_shared<A>();//这个指针就是一直有效的
     //如果使用指针就还得手动释放内存  就很麻烦所以用智能指针
     //不需要这个变量的时候就释放掉
     thread t(&A::foo, a); // 这个指针就是一直有效的
     
     t.join();
     return 0;
 }

互斥量解决多线程数据共享问题

数据共享问题分析

在多个线程中共享数据时，需要注意线程安全问题。如果多个线程同时访问同一个变量，并且其中至少有一个线程对该变量进行了写操作，那么就会出现数据竞争问题。数据竞争可能会导致程序崩溃、产生未定义的结果，或者得到错误的结果。

为了避免数据竞争问题，需要使用同步机制来确保多个线程之间对共享数据的访问是安全的。常见的同步机制包括互斥量、条件变量、原子操作等。

 //这个就是互相抢夺资源的代码
 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 using namespace std;
 int a = 0;
 void foo() {
     for (int i = 0; i <= 10000; i++) {
         a += 1;
     }
 }
 int main() {
     thread t1(foo);
     thread t2(foo);
 ​
     t1.join();
     t2.join();
     cout << a << endl;//输出17520  预期结果是20000 这就是互相抢夺资源了
     return 0;
 }

互斥锁解决

 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 #include<mutex>
 using namespace std;
 int a = 0;
 mutex mtx;
 void foo() {
     for (int i = 0; i < 10000; i++) {
         mtx.lock();//lock枷锁操作 如果不解锁其它线程是不能执行下面操作的
         a += 1;
         mtx.unlock();
     }
 }
 int main() {
     thread t1(foo);
     thread t2(foo);
 ​
     t1.join();
     t2.join();
     cout << a << endl;//输出是20000 
     return 0;
 }

互斥量死锁

 //这就是死锁  死锁就是func_1在等着m2的所有权  func_2在等着m1的所有权  但是他俩都再互相等所以就没有释放彼此的锁就产生了死锁
 #include<iostream>
 #include<thread>
 #include<mutex>
 using namespace std;
 ​
 mutex m1,m2;
 void func_1() {
     for (int i = 0; i < 50; i++) {
         m1.lock();
         m2.lock();
         m1.unlock();
         m2.unlock();
 ​
     }
     
 }
 void func_2() {
     for (int i = 0; i < 50; i++) {
         m2.lock();
         m1.lock();
         m2.unlock();
         m1.unlock();
 ​
     }
     
 }
 int main() {
     thread t1(func_1);
     thread t2(func_2);
 ​
     t1.join();
     t2.join();
     cout << "over" << endl;
     return 0;
 }
lock_guard 与 std::unique_lock

lock_guard的特点：

  • 当构造函数被调用时，该互斥锁会被自动锁定

  • 当析构函数被调用时，该互斥锁会被自动解锁

  • lock_guard对象不能复制或移动，因此只能在局部作用域中使用

 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 #include<mutex>
 using namespace std;
 int a = 0;
 mutex mtx;
 void foo() {
     for (int i = 0; i < 10000; i++) {
         lock_guard<mutex>lg(mtx);
         a += 1;
     }
 }
 int main() {
     thread t1(foo);
     thread t2(foo);
 ​
     t1.join();
     t2.join();
     cout << a << endl;//输出20000 
     return 0;
 }

unique_lock:

std:: 是 C++ 标准库中提供的一个互斥量封装类，用于在多线程程序中对互斥量进行加锁和解锁操作。它的主要特点是可以对互斥量进行更加灵活的管理，包括延迟加锁、条件变量、超时等。

std::unique_lock 提供了以下几个成员函数：

 `lock()`：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁。
 ​
 `try_lock()`：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则函数立即返回 `false`，否则返回 `true`。
 ​
 `try_lock_for(const std::chrono::duration<Rep, Period>& rel_time)`：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁，或者超过了指定的时间。
 ​
 `try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time)`：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁，或者超过了指定的时间点。
 ​
 `unlock()`：对互斥量进行解锁操作。

单例设计模式

单例设计模式是一种常见的设计模式，用于确保某个类只能创建一个实例。由于单例实例是全局唯一的，因此在多线程环境中使用单例模式时，需要考虑线程安全的问题。

下面是一个简单的单例模式的实现：

 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 #include<mutex>
 using namespace std;
 ​
 //日志功能就是单例模式 
 class Log {
 public:
     Log() {};
     Log(const Log& log) = delete;//在某些情况下，我们希望类的实例只能有一个。通过禁用拷贝构造函数，我们可以确保不会创建多个相同的实例。
     Log& operator = (const Log& log) = delete; 
 ​
     static Log& GetInstance() {//这样写就是全局只有一个log不会有第二个这就是懒汉模式
         //提前构造了一个对象 需要的时候就返回这个对象
         static Log log;
         return log;
         /*
         * static Log *log = nullptr;//饿汉模式
         * if(!log) log = new Log;
         * return *log;//提前不声明指针，需要的时候才创建对象
         */
     }
     void PrintLog(string msg) {
         cout << msg << endl;
 ​
     }
 };
 int main() {
     Log::GetInstance().PrintLog("error");
         return 0;
 }

call_once知识

多线程在单例模式中出现的一个问题：就是一下代码因为是单例模式但是线程调用两个线程是并行的 那就声明了两次

 ​
 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 #include<mutex>
 using namespace std;
 ​
 //日志功能就是单例模式 
 class Log {
 public:
     Log() {};
     Log(const Log& log) = delete;
     Log& operator = (const Log& log) = delete; 
 ​
     static Log& GetInstance() {//这样写就是全局只有一个log不会有第二个这就是懒汉模式
         //提前构造了一个对象 需要的时候就返回这个对象
         static Log log;
         return log;
         /*
         * static Log *log = nullptr;//饿汉模式
         * if(!log) log = new Log;
         * return *log;//提前不声明指针，需要的时候才创建对象
         */
     }
     void PrintLog(string msg) {
         cout << msg << endl;
 ​
     }
 };
 void printError() {
     
     Log::GetInstance().PrintLog("error");
 }
 int main() {
     thread t1(printError);
     thread t2(printError);
     t1.join();
     t2.join();
 ​
         return 0;
 }

我们就用call_once解决

 #include<iostream>
 #include<thread>
 #include<string>
 #include<memory>
 #include<mutex>
 using namespace std;
 ​
 //日志功能就是单例模式 
 static Log* log = nullptr;//饿汉模式
 static once_flag once;
 class Log {
 public:
     Log() {};
     Log(const Log& log) = delete;
     Log& operator = (const Log& log) = delete; 
 ​
     static Log& GetInstance() {//这样写就是全局只有一个log不会有第二个这就是懒汉模式
         提前构造了一个对象 需要的时候就返回这个对象
         //static Log log;
         //return log;
         
         if(!log) log = new Log;
         call_once(once, init);
         return *log;//提前不声明指针，需要的时候才创建对象
         
     }
     void PrintLog(string msg) {
         cout << msg << endl;
 ​
     }
     static void init() {
         if (!log) log = new Log;
     }   
 };
 void printError() {
     
     Log::GetInstance().PrintLog("error");
 }
 int main() {
     thread t1(printError);
     thread t2(printError);
     t1.join();
     t2.join();
 ​
         return 0;
 }

线程池的使用 写的

必要的东西：

- 一个线程数组（维护一堆线程）
- 任务队列
- 用户 /生产者向队列里加任务
- 线程数组派线程取任务

```
#include<iostream>
#include<thread>
#include<string>
#include<memory>
#include<mutex>
#include<condition_variable>
#include<queue>
#include<vector>
using namespace std;
#include<functional>
class ThreadPool {
public:
	ThreadPool(int numThreads) :stop(false) {
		for (int i = 0; i < numThreads; i++) {
			threads.emplace_back([this] {//添加任务  用了拉姆达表达式
				while (1) {
					unique_lock<mutex> lock(mtx);
					condition.wait(lock, [this] {//判断任务队列里面有没有任务 有就取
						return !tasks.empty() || stop;
						});
					if (stop && tasks.empty()) {
						return;
					}
					function<void()> task(move(tasks.front()));    
                    tasks.pop();
					lock.unlock();
					task();
				}
				});
		}
	}
	~ThreadPool() {
		{
			unique_lock<mutex> lock(mtx);
			stop = true;//代表线程结束了
		}
		condition.notify_all();
		for (auto& t : threads) {//自动类型推导 自动判断这个数组里面是什么类型
			t.join();
		}
	}
	template<class F,class... Args>
	void enqueue(F &&f,Args&&... args) {
		function<void()> task =
			bind(forward<F>(f),
			forward<Args>(args)...);
		{
			unique_lock<mutex> lock(mtx);
			tasks.emplace(move(task));
		}
		condition.notify_one();
		

	}
private:
	vector<thread> threads;//线程数组
	queue<function<void()>> tasks;

	mutex mtx;
	condition_variable condition;//条件变量
	bool stop;//线程池什么时候终止
 };
int main() {
	ThreadPool pool(4);
	for (int i = 0; i < 10; i++) {
		pool.enqueue([i]() {
			cout << "第几个任务" << i << "任务开始" << endl;
			this_thread::sleep_for(chrono::seconds(1));
			cout << "第几个任务" << i << "任务结束" << endl;
			});
	}
	return 0;
	 
}

```

别出Bug啊
关注
  • 27
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++11多线程库之线程库使用
03-25
c++11的多线程库使用方法例子，介绍了c++11和thread库的使用方法
C++11 ——— 线程库
2021dragon的博客
09-21 4844
在C++11之前，涉及到多线程问题，都是和平台相关的，比如Windows和Linux下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行了支持，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。
C++11的线程库
weixin_43743711的博客
04-17 2011
前言： C++ 11通过标准库引入了对多线程的支持，这个是c++的新特性之一，也就是说我们直接用即可，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念（这个后文会讲到）。线程啥的就不再解释了，直接上干货； 头文件一定记得写如下几个： #include <thread> //线程库 #include <condition_variable> //条件变量 #include <mutex> //互斥锁 1. 线程库函数的使用
C++11 多线程（std::thread）详解
热门推荐
jcShan709的博客
07-17 9万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
C++11---线程库
精致的灰的博客
01-26 1811
文章目录一、线程库的介绍1.1. 使用时的注意点1.2. 线程函数参数1.3. join与detach二、原子性操作库2.1. atomic2.2. 锁三、使用lambda表达式创建多个线程四、条件变量 一、线程库的介绍 在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包含&
C++11线程使用
Jason_Lee155的博客
08-03 1596
C++11线程使用线程概念构造函数成员函数使用线程创建详解用一个初始函数创建一个线程用类对象创建一个线程用lambda表达式创建一个线程认识一个函数 线程概念 C++11引入了thread类，大大降低了多线程使用的复杂度，原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需使用语言层面的thread可以解决这个问题。 所需头文件： #include <thread> 构造函数 1.默认构造函数 thread() noexce
c++11多线程库之互斥库使用
03-25
c++多线程库的使用demo，介绍了互斥库 mutex的使用方式
详解C++11 线程休眠函数
12-16
C++ 11之前并未提供专门的休眠函数。...从C++11开始，中C++标准库提供了专门的线程休眠函数，使得你的代码可以独立于不同的平台。 std::this_thread::sleep_for std::this_thread::sleep_untill 1. 让线
C、C++语言线程库的使用
12-17
C、C++语言线程库的使用
C++日志库-线程安全
04-28
C++线程安全日志库-Win32接口实现，博客讲解：https://www.cnblogs.com/swarmbees/ ->C++线程安全日志库-Win32接口实现
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 70
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 263
C语言如何在链表中的指定位置插⼊结点？
PyQt5 中的 List View
xy_optics的博客
05-16 823
有时候，标准模型可能无法满足特定的需求，这时可以自定义数据模型。自定义模型需要继承自 QAbstractItemModel 类，并实现一些关键的方法，如 data()、rowCount()、columnCount() 等，以便 List View 能够正确地显示数据。# 自定义数据模型类return 1# 使用自定义模型。
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 622
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 938
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
linux系统使用c++11的多线程库
05-07
Linux系统中使用C++11多线程库主要有两种方式：pthread和std::thread。 1. pthread：pthread是POSIX标准线程库，支持C++11标准之前的多线程编程。C++11中也可以使用pthread库实现多线程编程。pthread库需要手动管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值