《C++11：通过thread类编写C++多线程程序》

郭源潮12025-03-30 14:33

关于多线程的概念与理解，可以先了解Linux下的底层线程。当对底层线程有了一定程度理解以后，再学习语言级别的多线程编程就轻而易举了。

【Linux】多线程 -＞ 从线程概念到线程控制

【Linux】多线程 -＞ 线程互斥与死锁

语言级别的多线程编程最大的好处就是可以跨平台，使用语言级别编写的多线程程序不仅可以在Windows下直接编译运行，在Linux下也是可以直接编译运行的。其实本质还是调用了不同操作系统的底层线程API。

多线程简单使用

  • 怎么创建启动一个线程？
cpp 复制代码 
#include<iostream>
#include<thread>
#include<chrono>

void threadHandle1(int time)
{
	// 让线程休眠两秒
	std::this_thread::sleep_for(std::chrono::seconds(time));
	std::cout << "hello thread1" << std::endl;
}

int main()
{
	// 创建一个线程对象，传入线程函数以及线程函数所需要的参数，线程就开始执行了
	std::thread t1(threadHandle1, 2);

	// 主线程等待子线程结束，再继续往下运行
	t1.join();

	std::cout << "main thread done!" << std::endl;
	return 0;
}

主线程要t1.join()等待子线程结束之后才能向后运行。如果不等待，就会异常终止。

  • 子线程如何结束？

子线程函数运行完成就结束了。

也可以将线程设置为分离状态，主线程就可以不用等待子进程执行完再继续向后运行了。

cpp 复制代码 
void threadHandle1(int time)
{
	// 让线程休眠两秒
	std::this_thread::sleep_for(std::chrono::seconds(time));
	std::cout << "hello thread1" << std::endl;
}

int main()
{
	// 创建一个线程对象，传入线程函数以及线程函数所需要的参数，线程就开始执行了
	std::thread t1(threadHandle1, 2);

	// 主线程等待子线程结束，再继续往下运行
	// t1.join();

	// 设置线程为分离状态
	t1.detach();

	std::cout << "main thread done!" << std::endl;
	return 0;
}
  • 主线程如何处理子线程？

1、t1.join()等待线程，等待线程结束后主线程再继续向后运行。

2、t1.detach()分离线程，主线程结束，整个进程就结束了，所有线程都自动结束了。

cpp 复制代码 
#include<iostream>
#include<thread>
#include<chrono>

void threadHandle1(int time)
{
	// 让线程休眠time秒
	std::this_thread::sleep_for(std::chrono::seconds(time));
	std::cout << "hello thread1" << std::endl;
}

void threadHandle2(int time)
{
	// 让线程休眠time秒
	std::this_thread::sleep_for(std::chrono::seconds(time));
	std::cout << "hello thread1" << std::endl;
}

int main()
{
	// 创建一个线程对象，传入线程函数以及线程函数所需要的参数，线程就开始执行了
	std::thread t1(threadHandle1, 2);
	std::thread t2(threadHandle2, 2);
	// 主线程等待子线程结束，再继续往下运行
	t1.join();
	t2.join();
	// 设置线程为分离状态
	// t1.detach();

	std::cout << "main thread done!" << std::endl;
	return 0;
}

mutex互斥锁和lock_guard

cpp 复制代码 
#include<iostream>
#include<thread>
#include<list>

int tickets = 1000;

void getTicket(int i)
{
	// 模拟用户抢票的行为
	while (tickets > 0)
	{
		std::cout << "用户:" << i << "正在进行抢票！" << tickets << std::endl;
		tickets--;
		std::this_thread::sleep_for(std::chrono::microseconds(100));
	}
}

int main()
{
	std::list<std::thread> list;
	for (int i = 1; i <= 3; i++)
	{
		list.push_back(std::thread(getTicket, i));
	}
	for (std::thread &t: list)
	{
		t.join();
	}

	return 0;
}

输出的结果杂乱无章，并且抢票出现负数。

多线程对临界区的访问会存在竞态条件：临界区代码段在多线程环境下执行，随着线程的调度时许不同，从而产生不同的结果。所以，我们要保证对临界区的原子操作，是通过对临界区加锁完成的。

由于多个线程同时向标准输出流std::cout输出信息，会造成输出混乱，各线程的输出可能相互穿插。

在多线程环境下，多个线程同时访问和修改共享资源tickets，会引发数据竞争问题。比如，当一个线程检查到tickets>0后，在执行tickets--操作之前，另一个线程也可能检查到tickets>0，进而导致重复售票或者出现负数票数的情况。

++/--操作并不是原子性的，其实是对应三条汇编指令完成的。

  • 读取：从内存中把变量的值读取到寄存器
  • 修改：在寄存器里将变量的值+1/-1
  • 写入：把修改后的值写入到内存

在单线程环境下，这三个步骤顺序执行不会有问题。但是在多线程环境下，多个线程可能对同一个变量同时进行++/--操作，从而导致数据竞争的问题。

可以看下面的过程演示。

一：

二：

三：

C++11是通过加锁来保证++/--操作的原子性的。

cpp 复制代码 
#include<iostream>
#include<thread>
#include<list>
#include<mutex>

int tickets = 1000;
std::mutex mtx; // 全局的一把锁

void getTicket(int i)
{
	// 模拟用户抢票的行为
	while (tickets > 0)
	{
		mtx.lock();
		// 锁+双重判断，如果不双重判断，当tickets为1时，用户正在抢票还没有执行到tickets--，其他用户判断tickets>0，也进来了等待锁。
		// 用户抢票之后，其他用户获取到锁还会进行抢票。
		if (tickets > 0)
		{
            // 临界区代码段 - 加锁保护
			std::cout << "用户:" << i << "正在进行抢票！" << tickets << std::endl;
			tickets--;
			mtx.unlock();
		}
	}
}

int main()
{
	std::list<std::thread> list;
	for (int i = 1; i <= 3; i++)
	{
		list.push_back(std::thread(getTicket, i));
	}
	for (std::thread &t: list)
	{
		t.join();
	}

	return 0;
}

通过加锁和双重判断的方式，这样就能做到对多线程对共享资源tickets的安全访问了。

lock_guard和unique_lock

其实不需要我们手动加锁和解锁，因为，如果临界区内有return，break等语句，此线程获取锁，但是在释放锁之前break或者renturn了，导致锁没有释放。那么其他线程也获取不了锁，就会造成死锁问题，所以对于这把互斥锁要有RAII的思想。

使用lock_guard。构造函数获取锁，析构函数释放锁。

cpp 复制代码 
int tickets = 1000;
std::mutex mtx; // 全局的一把锁

void getTicket(int i)
{
	// 模拟用户抢票的行为
	while (tickets > 0)
	{
		{
			std::lock_guard<std::mutex> lock(mtx);
			// mtx.lock();
			// 锁+双重判断，如果不双重判断，当tickets为1时，用户正在抢票还没有执行到tickets--，其他用户判断tickets>0，也进来了等待锁。
			// 用户抢票之后，其他用户获取到锁还会进行抢票。
			if (tickets > 0)
			{
				std::cout << "用户:" << i << "正在进行抢票！" << tickets << std::endl;
				tickets--;
			}
			// mtx.unlock();
		}
		std::this_thread::sleep_for(std::chrono::microseconds(100));
	}
}

不管临界区是正常执行，还是break或return了，出了作用域，lock_guard会自动调用析构函数释放锁，保证所有线程都能释放锁，避免死锁问题发生。

lock_guard不支持拷贝构造和赋值运算符重载，如果需要拷贝和赋值可以使用unique_lock，支持移动语义，可以使用右值引用的拷贝构造和赋值运算符重载。

cpp 复制代码 
int tickets = 1000;
std::mutex mtx; // 全局的一把锁

void getTicket(int i)
{
	// 模拟用户抢票的行为
	while (tickets > 0)
	{
		{
			std::unique_lock<std::mutex> lck(mtx);
			// std::lock_guard<std::mutex> lock(mtx);
			// mtx.lock();
			// 锁+双重判断，如果不双重判断，当tickets为1时，用户正在抢票还没有执行到tickets--，其他用户判断tickets>0，也进来了等待锁。
			// 用户抢票之后，其他用户获取到锁还会进行抢票。
			if (tickets > 0)
			{
				std::cout << "用户:" << i << "正在进行抢票！" << tickets << std::endl;
				tickets--;
			}
			// mtx.unlock();
		}
		std::this_thread::sleep_for(std::chrono::microseconds(100));
	}
}

总结：lock_guard不能用在函数传递或返回的过程中，因为lock_guard删除了拷贝构造和赋值，只能用在简单的临界区代码段的互斥操作中。unique_guard可以用在函数传递或返回的过程中，因为支持移动语义，可以使用移动构造和移动赋值。unique_guard通常与条件变量一起使用。

线程间的同步通信

生产者-消费者模型

cpp 复制代码 
std::mutex mtx;
std::condition_variable cv;

// 边生产边消费
class Queue
{
public:
	void put(int val)
	{

		// 加锁
		std::unique_lock<std::mutex> lock(mtx);
		// 如果队列不为空，则等待
		while (!que.empty())
		{
			// 1.进入等待状态 2.释放锁
			cv.wait(lock);
			// 被唤醒之后，等待状态进入阻塞状态，获取锁进入就绪状态继续执行
		}
		que.push(val);
		cv.notify_all(); // 通知消费者消费
		std::cout << "生产者 生产：" << val << "号物品" << std::endl;
	}
	int get()
	{
		// 加锁
		std::unique_lock<std::mutex> lock(mtx);
		// 如果队列为空，则等待
		while (que.empty())
		{
			// 1.进入等待状态 2.释放锁
			cv.wait(lock);
			// 被唤醒之后，等待状态进入阻塞状态，获取锁进入就绪状态继续执行
		}
		int val = que.front();
		que.pop();
		cv.notify_all(); // 通知生产者生产
		std::cout << "消费者 消费：" << val << "号物品" << std::endl;

		return val;
	}
private:
	std::queue<int> que;
};


// 生产
void producer(Queue* que)
{
	for (int i = 0; i <= 10; i++)
	{
		que->put(i);
		std::this_thread::sleep_for(std::chrono::microseconds(100));
	}
}
// 消费
void conducer(Queue* que)
{
	for (int i = 0; i <= 10; i++)
	{
		que->get();
		std::this_thread::sleep_for(std::chrono::microseconds(100));
	}
}
int main()
{
	Queue que;
	std::thread p(producer, &que);
	std::thread c(conducer, &que);
	p.join();
	c.join();
	return 0;
}
相关推荐
Y1nhl11 分钟前
搜广推校招面经八十一
开发语言·人工智能·pytorch·深度学习·机器学习·推荐算法·搜索算法
Algorithm157612 分钟前
谈谈接口和抽象类有什么区别？
java·开发语言
Starry_hello world13 分钟前
C++ 快速幂算法
c++·算法·有问必答
yu41062114 分钟前
Rust 语言使用场景分析
开发语言·后端·rust
良艺呐^O^15 分钟前
uniapp实现app自动更新
开发语言·javascript·uni-app
264玫瑰资源库2 小时前
问道数码兽 怀旧剧情回合手游源码搭建教程（反查重优化版）
java·开发语言·前端·游戏
普if加的帕3 小时前
java Springboot使用扣子Coze实现实时音频对话智能客服
java·开发语言·人工智能·spring boot·实时音视频·智能客服
2301_807611493 小时前
77. 组合
c++·算法·leetcode·深度优先·回溯
安冬的码畜日常3 小时前
【AI 加持下的 Python 编程实战 2_10】DIY 拓展：从扫雷小游戏开发再探问题分解与 AI 代码调试能力（中）
开发语言·前端·人工智能·ai·扫雷游戏·ai辅助编程·辅助编程
朝阳5814 小时前
Rust项目GPG签名配置指南
开发语言·后端·rust
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）