C++多线程并发 基础入门教程

已于 2022-03-25 21:30:50 修改
阅读量1.4k 收藏 4
点赞数 2
CC 4.0 BY-SA版权
文章标签： c++
于 2022-03-22 22:20:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muguang629/article/details/123671092
本文详细介绍了C++中的多线程编程基础，包括如何创建线程、线程同步（互斥量、死锁处理）、原子变量、条件变量与信号量的应用，以及promise和future的概念和使用。通过实例展示了如何避免资源竞争，解决线程间通信问题，以及如何通过std::async简化异步任务执行。此外，还提到了std::packaged_task用于任务封装的特性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本文为教程C++ 多线程并发 基础入门教程的学习笔记

1.基础知识

1.1 创建一个线程

std::thread thread1(函数名,函数的参数列表)

#include <iostream>
#include <thread>

void func(int a){
	...
	}
int main(){
	int a = 0;
	std::thread thread1(func,a);	//创建一个线程thread1并开始执行
	while(true);
	}

如果main()中不加while(true)，则会报错，因为主线程执行完毕后会退出，而子线程还没有执行完毕，因此会报错。
解决方案

1.1.1 调用成员函数join()

该成员函数会将主线程阻塞住，直到子线程结束

#include <iostream>
#include <thread>

void func(int a){
	...
	}
int main(){
	int a = 0;
	std::thread thread1(func,a);	//创建一个线程thread1并开始执行
	thread1.join();	//阻塞主线程，直到子线程thread1执行完毕
	}
1.1.2.调用成员函数detach()

该成员函数会将主线程和子线程完全分开，不等待子线程执行完毕，直接执行下一条语句。

#include <iostream>
#include <thread>

void func(int a){
	...
	}
int main(){
	int a = 0;
	std::thread thread1(func,a);	//创建一个线程thread1并开始执行
	thread1.detach();	//将子线程和主线程完全分开
	}

尽量不要使用detach

1.2 常用成员

get_id()：获取线程id
hardware_concurrency()：返回当前硬件支持的最大并发数

1.3 在函数中获取执行该函数的线程信息

std::this_thread::get_id()：获取执行当前函数的线程号

#include <iostream>
#include <thread>

void func(int a){
	std::cout<<std::this_thread::get_id()<<std::endl;//输出执行当前线程的线程号
	std::this_thread::sleep_for(std::chrono::microseconds(50));	//休眠50ms
	}
int main(){
	int a = 0;
	std::thread thread1(func,a);	//创建一个线程thread1并开始执行
	thread1.join();	//阻塞主线程，直到子线程thread1执行完毕
	}

2. 互斥量及死锁现象

2.1 基础知识

如果两个线程同时访问一个公共资源（如全局变量），便会导致该公共资源不安全，如：

#include <iostream>
#include <thread>

int globalVar = 0;
void task1{
	for (int i = 0; i<10000 ;i++){
		globalVar++;
		globalVar--;
		}
	}
int main(){
	std::thread t1(task1);
	std::thread t2(task1);
	
	t1.join();
	t2.join();
	std::cout<<globalVar<<std::endl;
	}

该程序输出的结果不会是0，因为两个线程都在访问globalVar。解决方法：使用互斥量

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int globalVar = 0;

void task1{
	for (int i = 0; i<10000 ;i++){
		mtx.lock();
		globalVar++;
		globalVar--;
		mtx.unlock();
		}
	}
int main(){
	std::thread t1(task1);
	std::thread t2(task1);
	
	t1.join();
	t2.join();
	std::cout<<globalVar<<std::endl;
	}

此时程序输出为0

2.2 死锁现象与解决方式

使用mutex可能会产生死锁现象，如
2.2.1.上锁顺序不同导致死锁
例程中两个线程都在等待，形成死锁。

void task1(){
	mtx1.lock();
	mtx2.lock();
	...
	mtx2.unlock();
	mtx1.unlock();
	}
void task2(){
	mtx2.lock();
	mtx1.lock();
	...
	mtx1.unlock();
	mtx2.unlock();
	}

解决方法

  1. 不同函数中上锁的时候，保持同样的上锁顺序
  2. 使用std::lock()代替多个锁上锁
void task1(){
	std::lock(mtx1,mtx2);
	...
	mtx1.unlock();
	mtx2.unlock();
	}

2.2.2 程序中途返回造成死锁
例程中程序提前返回，mtx1没有解锁

void task1(){
	mtx1.lock();
	if (1 == 1) return;
	mtx1.unlock();
	}

解决方法：使用标准库中的模板类std::lock_guard <std::mutex>或std::unique_lock <std::mutex>，这两个类会在构造的时候上锁，析构的时候解锁。
其中std::unique_lock <std::mutex>使用更灵活，该类中有多个成员函数，可以自由控制解锁，而不必等到析构时才能解锁。例：

void task1(){
	std::lock_guard <std::mutex> lock1(mtx1);
	if (1 == 1) return;
	std::cout<<"Have not return"<<std::endl;
	}
void task2(){
	std::unique_lock <std::mutex> lock2(mtx2);
	if (1 == 1) return;
	std::cout<<"Have not return"<<std::endl;
	lock2.unlock();
	std::cout<<"Have not return but have unlocked"<<std::endl;
	}

2.3 原子变量

原子变量能够不通过互斥量、锁的方式避免资源竞争
将可能产生竞争的全局变量定义为如下方式即可

#include <atomic>

std::atomic<int> globalVar = 0;

通过原子变量可以避免资源竞争，其具体实现方式依编译器而定，有的是编译器自动为不同的函数上锁，有的是通过CPU硬件的方式来实现，不必纠结这点。

2.3.1 atomic_flag

定义 std::atomic_flag odom_lock_ = ATOMIC_FLAG_INIT;
使用（两个成员函数）

  • odom_lock_.test_and_set()
    先获取状态作为返回值，然后设置成true（经过这个语句后flag一定是true）
  • odom_lock_.clear()
    清除 std::atomic_flag 对象的标志位，即设置 atomic_flag 的值为 false

3. 条件变量与信号量（控制线程通断）

3.1 条件变量

观察如下程序

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <deque>

std::mutex mtx;
std::deque<int> q;

//producer
void task1(){
	int i = 0;
	while (true){
		std::unique_lock<std::mutex> lock(mtx);
		q.push_back(i);
		if (i<9999){
			i++;
			}
		else{
			i = 0;
			}
		}
	}

//consumer
void task2(){
	int data = 0;
	while (true){
		std::unique_lock<std::mutex> lock(mtx);
		if (!q.empty()){
			data = q.front();
			q.pop_front();
			std::cout<<"get value from que :"<<data<<std::endl;
			}
		}
	}
int main(){
	std::thread t1(task1);
	std::thread t1(task2);
	t1.join();
	t2.join();
	}

该程序会因为task2循环不断地检查队列是否为空而消耗大量的CPU资源，因此需要寻找一种方式能够降低CPU资源占用——条件变量，通过条件变量可以使线程进入睡眠、唤醒线程。

  • 条件变量头文件：#include <condition_variable>
  • 定义方式：std::condition_variable name;
#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <deque>
#include <condition_varibale>

std::mutex mtx;
std::deque<int> q;
std::condition_variable cv;

//producer
void task1(){
	int i = 0;
	while (true){
		std::unique_lock<std::mutex> lock(mtx);
		q.push_back(i);
		cv.notify_one();	//随机唤醒当前陷入休眠的一个线程
		//cv.notify_all();	//唤醒当前所有休眠的一个线程
		if (i<9999){
			i++;
			}
		else{
			i = 0;
			}
		}
	}

//consumer
void task2(){
	int data = 0;
	while (true){
		std::unique_lock<std::mutex> lock(mtx);
		if (q.empty()){
			cv.wait(lock);	//如果队列q为空，则该线程陷入休眠状态
							//此时不再需要锁lock，因此传入lock，cv.wait会将lock解锁
							//唤醒后是继续这条向下执行，还是从头执行函数task2有待验证
			}
		
		data = q.front();
		q.pop_front();
		std::cout<<"get value from que :"<<data<<std::endl;
		}
	}
int main(){
	std::thread t1(task1);
	std::thread t1(task2);
	t1.join();
	t2.join();
	}

3.2 信号量(唤醒特定数量的线程)

  • 信号量会在内部维护一个计数器，根据计数器的值来确定线程通断。
  • 头文件：#include <semaphore>
  • 定义方式
    std::counting _semaphore<MaxValue> csem(num1);
    std::binary_semaphore bsem(num1);
    其中后者是前者的特化，相当于std::counting _semaphore<1> bsem(num1);
    num1为内部计数器的初始值，MaxValue为内部计数器的最大值
  • 成员函数
    bsem、csem会在内部维护一个计数器
    当调用release(num2)时，内部计数器+num2，缺省为+1，注意num2需要小于MaxValue
    当调用acquire()时，内部计数器-1，当结果为负值时，线程便会阻塞在acquire处
	csem.acquire();
	csem.release(num2);
	bsem.acquire();
	bsem.release();

4.promise和future

4.1 简介

首先来看一段有问题的程序

例程4.1
#include <iostream>
#include <thread>
#include <future>

void task(int a,int b,int& ret){
		int ret_a = a*a;
		int ret_b = b*2;
		ret = ret_a+ret_b;
	}
int main(){
		int ret = 0;
		std::thread t(task,1,2,std::ref(ret));
		std::cout<<"the Value is"<<ret;
		t.join();
	}

在这段程序中，主线程和子线程都使用了公共资源ret，因此需要加锁。加锁不仅加大了代码量，还需要定义全局变量（std::mutex mtx）。
为解决这个问题，标准库提供了std::promise<>和std::future<>两个模板类，具体用途及方法见例程。

例程4.2
#include <iostream>
#include <thread>
#include <future>

void task(int a,int b,std::promise<int>& ret){
		int ret_a = a*a;
		int ret_b = b*2;
		ret.set_value(ret_a+ret_b);//对p_ret进行赋值
	}
int main(){
		int ret = 0;
		std::promise<int> p_ret;
		std::future<int> f_ret = p_ret.get_future();//定义promise和future，并建立二者之间的联系
		
		std::thread t(task,1,2,std::ref(p_ret));//将p_ret以引用传递的方式传入
		/* do something else*/
		std::cout<<"the Value is"<<f_ret.get();//运行到future.get()的时候，程序会一直阻塞在这里，直到promise被set_value()
		t.join();
	}

注意，future的get()操作只能进行一次，否则程序会crash

考虑promise和future的其他用途，比如某个子线程需要两个参数，只有一个参数已知，另一个目前还未知，可以通过promise和future让子线程先对已知的部分进行计算，等到未知参数传入后再进行剩余部分的计算，具体例程如下

#include <iostream>
#include <thread>
#include <future>

void task(int a,std::future<int>& b,std::promise<int>& ret){
		int ret_a = a*a;
		int ret_b = b.get() * 2;	//子线程被阻塞在这里
		ret.set_value(ret_a+ret_b);//对p_ret进行赋值
	}
int main(){
		int ret = 0;
		std::promise<int> p_ret;
		std::future<int> f_ret = p_ret.get_future();//定义promise和future，并建立二者之间的联系

		std::promise<int> p_in;
		std::future<int> f_in;
		
		std::thread t(task,1,std::ref(f_in),std::ref(p_ret));//将p_ret、f_in以引用传递的方式传入
		/* do something else*/
		p_in.set_value(2);	//这里获得了第二个参数的值，set进去，此时被阻塞的子进程被激活
		std::cout<<"the Value is"<<f_ret.get();//运行到future.get()的时候，程序会一直阻塞在这里，直到promise被set_value()
		t.join();
	}

4.2 多个线程需要使用future

future对象的成员函数get()只能调用一次，那如果有很多线程需要那个数据呢——可以使用模板类std::shared_future<>

#include <iostream>
#include <thread>
#include <future>

void task(int a,std::shared_future<int> b,std::promise<int>& ret){
		int ret_a = a*a;
		int ret_b = b.get() * 2;	//子线程被阻塞在这里
		ret.set_value(ret_a+ret_b);//对p_ret进行赋值
	}
int main(){
		int ret = 0;
		std::promise<int> p_ret;
		std::future<int> f_ret = p_ret.get_future();//定义promise和future，并建立二者之间的联系

		std::promise<int> p_in;
		std::future<int> f_in;
		
		std::shared_future<int> s_f = f_in.share();
		
		std::thread t0(task,1,s_f,std::ref(p_ret));//将p_ret以引用方式传递，s_f以值传递方式传递
		std::thread t1(task,1,s_f,std::ref(p_ret));//s_f在值传递过程中，在每个线程中都被复制一份，因此不会影响get的使用
		std::thread t2(task,1,s_f,std::ref(p_ret));
		std::thread t3(task,1,s_f,std::ref(p_ret));
		/* do something else*/
		p_in.set_value(2);	//这里获得了第二个参数的值，set进去，此时被阻塞的子进程被激活
		std::cout<<"the Value is"<<f_ret.get();//运行到future.get()的时候，程序会一直阻塞在这里，直到promise被set_value()
		t.join();
	}

shared_future可以被复制，可以直接值传递。这时每个线程都会持有一份复制的shared_future，不必担心get的问题了。而promise和future都不可复制，必须使用引用传递，要想复制只能通过std::move来移动复制

4.3 复制性

promise和future都不可复制，必须使用引用传递，如果想要复制需要使用std::move
shared_future可以复制，可以使用值传递

5.std::async() 自由控制是否新建线程

利用第4节中提到的promise和future编写的程序仍不够简化，需要定义线程、promise、future，代码量仍然较大。可以利用标准库提供的函数std::async()进行简化，例程4.2可以简化为如下形式

#include <iostream>
#include <thread>
#include <future>

int task(int a,int b){
		int ret_a = a*a;
		int ret_b = b*2;

		return ret_a+ret_b;
	}
int main(){
/*
		int ret = 0;
		std::promise<int> p_ret;
		std::future<int> f_ret = p_ret.get_future();//定义promise和future，并建立二者之间的联系
		
		std::thread t(task,1,2,std::ref(p_ret));//将p_ret以引用传递的方式传入
		//do something else
		std::cout<<"the Value is"<<f_ret.get();//运行到future.get()的时候，程序会一直阻塞在这里，直到promise被set_value()
		t.join();
*/
		std::future<int> fu = std::async(task,1,2);
		std::cout<<"the value is"<<fu.get();
	}

std::async()的返回类型为std::future，参数列表为std::async(type,func,args)，其中

  • type分为std::launch::async和std::launch::deferred，缺省为std::launch::deferred
    std::launch::async表示新开一个线程进行func函数的调用，而std::launch::deferred则不新开一个子线程，只有在std::async()返回的std::future进行get()调用的时候，才会进行计算。
    也就是说，使用std::async()并不等于新建了一个线程，需要自己指定是否新建线程，只有参数为std::launch::async的时候才在子线程进行计算
  • func是需要调用的函数名
  • args是func的参数列表
  • 注意此时的被调用函数task不再是void类型，而是int类型，使用async的时候不再需要引用传回函数计算结果，只需函数return需要的类型，再用同类型的std::future<>接受即可

6. std::packaged_task<> 任务封装

模板类std::packaged_task<>类似于std::bind()，但是更适合多线程使用，因为std::packaged_task<>能够与std::future联系起来，从而更方便多线程使用。

6.1 使用方式

std::packaged_task<RetType(argstype)> test(func_name);
func_name为需要调用的函数名
RetType为func_name的返回类型
argstypes为func的参数列表类型

例程

#include <iostream>
#include <thread>
#include <future>

int task(int a,int b){
		int ret_a = a*a;
		int ret_b = b*2;

		return ret_a+ret_b;
	}
int main(){
		std::packaged_task<int(int,int)> t(task);	//完成对任务的包装

		t(1,2);	//在其他地方完成任务调用
		std::cout<<"the value is"<<t.get_future().get()<<std::endl;	//利用成员函数get_future()获取future类对象，再get()到数值
	}

6.2 提前设定好某些参数——与std::bind()联合使用

#include <iostream>
#include <thread>
#include <future>

int task(int a,int b){
		int ret_a = a*a;
		int ret_b = b*2;

		return ret_a+ret_b;
	}
int main(){
		//std::packaged_task<int(int,int)> t(task);	//完成对任务的包装
		std::packaged_task<int> t(std::bind(task,1,2));	// 可以简化为auto t(std::bind(task,1,2))

		t();	//在其他地方完成任务调用
		std::cout<<"the value is"<<t.get_future().get()<<std::endl;	//利用成员函数get_future()获取future类对象，再get()到数值
	}
暮光629
关注
C++多线程基础教程
08-20 220
目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： 实例 生产者消费者问题 4 C++多线程高级知识 5 延伸拓展 1 什么是C++多线程？ 线程：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，进程包含一个或者多个线程。进程可以理解为完成一件事的完整解决方案，而线程可以理解为这
C++多线程教程（一）基本语法
Xiaoqing的博客
03-05 631
简介 C++ 11 之后有了标准的线程库：std::thread。本文针对thread介绍多线程的基本语法，并做案例展示。 基本语法 头文件: #include <thread> thread 参数： thread(Fn&& fn, Args&&… args); 说白了fn就是需要执行的函数指针（函数名），args是需要传入fn的参数 threa...
C++多线程编程（教程+Demo)代码
11-08
C++多线程编程（教程+Demo)代码，亲测通过，教程详细。
c++多线程编程
最新发布
小刘同学321的博客
06-26 675
C++11多线程编程，涵盖线程创建、同步、异步、线程池与原子操作。
C++ 之多线程简单教程
Neverland_LY‘s Domain
04-15 796
· 多线程简介 多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理（Chip-level multithreading）或同时多线程（Simultaneous multithreading）处理...
C++多线程入门
越努力越幸运—liupu
12-14 9671
一.概念 在讲解多线程之前，有些概念还是有必要了解清楚的。这里详细地讲解了一下，请先耐心看完。当然，我也是刚入门，只是叙述一下我的理解，如有错误还望海涵，OS大牛也可以直接跳过。 ①程序，进程，线程的区别 程序：程序是由一系列的指令和逻辑组成的一个静态文件（如cpp文件），无论能不能运行，它都客观的存在于储存器中。 进程：进程是计算机中的程序关于某数据集合上的一次运行活动，是系
C++多线程并发基础入门教程
南风fahaxiki
09-16 1209
线程：线程是操作系统能够进行CPU调度的最小单位，它被包含在进程之中，一个进程可包含单个或者多个线程。可以用多个线程去完成一个任务，也可以用多个进程去完成一个任务，它们的本质都相当于多个人去合伙完成一件事。多线程并发：多线程是实现并发(双核的真正并行或者单核机器的任务切换都叫并发）的一种手段，多线程并发即多个线程同时执行,一般而言，多线程并发就是把一个任务拆分为多个子任务，然后交由不同线程处理不同子任务,使得这多个子任务同时执行。
多线程编程的入门教程
03-04
标题所指的知识点是“多线程编程的入门教程”，这意味着本文档是为那些刚接触多线程编程的初学者提供的基础教学材料。通过这个标题，我们可以推断文档内容会从最基础的多线程概念讲起，逐渐过渡到实际编程技巧和例子...
C++多线程编程视频教程（C++11多线程并发）【122212】多线程API详解（一）.rar
03-13
《C++面向对象多线程编程》推荐：毫无疑问，这是我见过的最好的、最全面...只要不是刚刚入门的C++程序员都可以从《C++面向对象多线程编程》受益良多；不仅多线程编程的核心内容值得研习，书中的优秀源代码也可供借鉴。
C++多线程编程基础教程：并发与通信解析
"C++多线程入门电子书深入解析了C++中的多线程技术，旨在帮助初学者理解和掌握这一核心概念。" C++多线程技术是现代编程中的重要组成部分，尤其在需要高效利用计算资源和提升软件响应速度的应用中不可或缺。在C++11...
C++多线程编程入门教程
08-10
C++多线程编程入门教程 本文将对C++多线程编程进行详细的介绍，从多线程概念的定义到实际的编程实现。同时，文章还将对Linux和Windows平台下的多线程实现进行比较，并提供了相关的示例代码。 一、多线程概念 在...
C++多线程编程（教程+Demo)
12-10
Win32 SDK函数支持进行多线程的程序设计，并提供了操作系统原理中的各种同步、互斥和临界区等操作。Visual C++ 6.0中，使用MFC类库也实现了多线程的程序设计，使得多线程编程更加方便。 该教程提供了由浅入深的讲解及Demo，对初学多线程编程很有帮助。
C++线程、多线程教程详解（全网最全、示例最多、最详细）（第一篇）
shuai_258的博客
09-06 1712
我们可以封装线程操作，定义一个线程类来简化线程管理。private:public:// 构造函数，接受函数和参数来启动线程// 加入线程（等待线程完成）t.join();// 分离线程（让线程独立运行）t.detach();// 析构函数，确保线程对象在销毁前已被处理t.join();// 通常在析构时，选择 join 或 detach 来处理未处理的线程// 使用类来管理线程// 等待线程完成return 0;解释使用模板构造函数来创建线程，并且使用保证参数的完美转发。
c++基本使用教程（多线程）
T的专栏
12-18 1047
多线程 http://www.runoob.com/cplusplus/cpp-multithreading.html 一、子线程方法编写规范：输入参数是(void* args) 返回是 void * 例如： void *myWebRtcSendData(void* args)   二、线程正常终止的方法： 1、return从线程函数返回（正常执行完函数）。 2、通过调用函数pthre...
学习C++多线程基础
weixin_43701019的博客
05-15 303
学习C++的过程中我们经常会用到.和::和：和->，在此整理一下这些常用符号的区别。 1、A.B则A为对象或者结构体； 2、A->B则A为指针，->是成员提取，A->B是提取A中的成员B，A只能是指向类、结构、联合的指针； 3、::是作用域运算符，A::B表示作用域A中的名称B，A可以是名字空间、类、结构； ...
【C++】多线程编程图文详解（多角度详解，小白一看就懂！！）
weixin_45031801的博客
10-07 7823
关于 多线程 相关操作，Linux 选择使用的是 POSIX 标准，而 Windows 没有选择 POSIX 标准，反而是自己搞了一套 API 和系统调用，称为 Win32 API，意味着 Linux 与 Windows 存在标准差异，直接导致能在 Linux 中运行的程序未必能在 Windows 中运行
C++11多线程并发基础入门教程
huangdenan的博客
06-03 137
https://zhuanlan.zhihu.com/p/194198073 https://blog.csdn.net/c_base_jin/article/details/89741247
c++ 并发入门
Peace
03-24 254
老铁，以下几本书，入门几乎够了，打开c++11+并发编程，内存模型的大门： 1. 《C++ Concurrency in Action 2nd Edition》 -- 绝对经典！ 2. 《Effective Modern C++》--chapter 7 3. 《深入理解c++ 11》 ...
C++ 多线程入门
HQYJ520的博客
05-18 312
目录： 第一个demo, std::thread join的用法 互斥/加锁 std::mutex 互斥量的基本使用 更好用的 std::unique_lock 条件变量实现"生产者/消费者模式" Future使用 补充&参考资料 第一个demo, std::thread c++ 11之后提供了thread库，方便的实现并发,使用std::thread创建子线程，参数有三种： 函数指针
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值