C++ 多线程学习总结

已于 2023-08-05 15:07:15 修改
阅读量267 收藏
点赞数
分类专栏： C/C++ 文章标签： c++
于 2023-07-16 10:50:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxu324/article/details/131748050
版权

C++ 多线程

  • 头文件
#include <thread>

创建线程 thread

jion与detach方式的区别

  • jion方式：必须等待已经创建的子线程任务执行完毕，才会继续往下执行。
    示例：
void my_func1_task()
{
	cout << "I am my_func1_task" << endl;
	cout << "my_func1_task end" << endl;
}

void my_func2_task(int x)
{
	cout << "I am my_func2_task" << endl;
	while (x--)
	{
		cout << "x:" << x << ";";
		sleep(1);
	}
	cout << endl;
	cout << "my_func2_task end" << endl;
}

int main(int argc, char *argv[])
{
	cout << "this is main()" << endl;
	thread thread_1(my_func1_task);
	//等待线程1完成
	thread_1.join();
	
	thread thread_2(my_func2_task, 10);
	//等待线程2完成
	thread_2.join();
	cout << "thread end" << endl;

	cout << "main end" << endl;
	return 0;
}

测试结果：
在这里插入图片描述

  • detach方式：启动的子线程自主在后台运行，当前主线程代码继续往下执行，无需等待子线程结束。
    注：该种情况下，主线程一般会进入while(1)循环执行主线程逻辑，否则整个进程会结束。
    示例：
void my_func1_task()
{
	cout << "I am my_func1_task" << endl;
	cout << "my_func1_task end" << endl;
}

void my_func2_task(int x)
{
	cout << "I am my_func2_task" << endl;
	while (x--)
	{
		cout << "x:" << x << ";";
		sleep(1);
	}
	cout << endl;
	cout << "my_func2_task end" << endl;
}

int main(int argc, char *argv[])
{
	cout << "this is main()" << endl;
	thread thread_1(my_func1_task);
	thread_1.detach();
	
	thread thread_2(my_func2_task, 10);
	thread_2.detach();
	cout << "thread end" << endl;

	cout << "main end" << endl;
	return 0;
}

测试结果：
在这里插入图片描述

互斥锁 mutex

  • 头文件
#include <mutex>

lock和unlock

不上锁测试示例：

int g_count = 10;

void my_func1_task()
{
	while (g_count-- > 0)
	{
		cout << "===func1===";
		sleep(1);
	}
	cout << endl;
}

void my_func2_task()
{
	while (g_count-- > 0)
	{
		cout << "***func2***";
		sleep(1);
	}
	cout << endl;
}

int main(int argc, char *argv[])
{
	cout << "this is main()" << endl;
	thread thread_1(my_func1_task);
	thread thread_2(my_func2_task);
	
	thread_1.join();
	thread_2.join();
	return 0;
}

测试结果：
在这里插入图片描述
上锁测试示例：

int g_count = 10;
mutex g_countMtx;

void my_func1_task()
{
	g_countMtx.lock();
	while (g_count-- > 0)
	{
		cout << "===func1===";
		sleep(1);
	}
	cout << endl;
	g_countMtx.unlock();
}

void my_func2_task()
{
	g_countMtx.lock(); 
	while (g_count-- > 0)
	{
		cout << "***func2***";
		sleep(1);
	}
	cout << endl;
	g_countMtx.unlock();
}

int main(int argc, char *argv[])
{
	cout << "this is main()" << endl;
	thread thread_1(my_func1_task);
	thread thread_2(my_func2_task);
	
	thread_1.join();
	thread_2.join();
	return 0;
}

测试结果：
在这里插入图片描述

lock_guard

  • 作用：防止在lock后，忘记unlock。
  • 使用：在创建lock_guard对象时，将尝试获取提供给它的互斥锁的所有权。当控制流离开lock_guard对象的作用域时，lock_guard析构并释放互斥锁。
  • 特点：创建即加锁，作用域结束自动析构并解锁；不能中途解锁，必须等作用域结束才能解锁。
  • 使用技巧：可以根据需要通过使用{}增加临时作用域。
测试示例-不加锁
int g_count = 0;

void func_1_task()
{
    while (1) {
        cout << "-------------------------" << endl;
        cout << "--- set count: " << ++g_count << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }
}

void func_2_task()
{
    while (1) {
        cout << "*************************" << endl;
        cout << "***111 get count: " << g_count << endl;
        this_thread::sleep_for(chrono::seconds(1));
        cout << "***222 get count: " << g_count << endl;
        this_thread::sleep_for(chrono::seconds(1));
    }
}

int main()
{
    thread th_1(func_1_task);
    th_1.detach();
    thread th_2(func_2_task);
    th_2.detach();

    while (1)
    {
        this_thread::sleep_for(chrono::seconds(10));
    }
    return 0;
}

测试结果
在这里插入图片描述

测试示例-加锁
int g_count = 0;
mutex g_countMtx;

void func_1_task()
{
    while (1) {
        {
            lock_guard<mutex> guard(g_countMtx);
            cout << "-------------------------" << endl;
            cout << "--- set count: " << ++g_count << endl;
        }
        this_thread::sleep_for(chrono::seconds(1));
    }
}

void func_2_task()
{
    while (1) {
        {
            lock_guard<mutex> guard(g_countMtx);
            cout << "*************************" << endl;
            cout << "***111 get count: " << g_count << endl;
            this_thread::sleep_for(chrono::seconds(1));
            cout << "***222 get count: " << g_count << endl;
        }
        this_thread::sleep_for(chrono::seconds(1));
    }
}

int main()
{
    thread th_1(func_1_task);
    th_1.detach();
    thread th_2(func_2_task);
    th_2.detach();

    while (1)
    {
        this_thread::sleep_for(chrono::seconds(10));
    }
    return 0;
}

测试结果
在这里插入图片描述

信号量 sem

C++下使用的信号量，实际上使用的也是C语言中的信号量，即使用<semaphore.h>库。

sem参数

  • 头文件
#include <semaphore.h>
  • 类型
    sem_t
  • 函数接口
int sem_init(sem_t *sem, int pshared, unsigned int value);  // 创建信号量
int sem_post(sem_t *sem);    // 信号量的值加 1
int sem_wait(sem_t *sem);    // 信号量的值减 1
int sem_destroy(sem_t *sem); // 信号量销毁

示例

sem_t sem;

void func_1_task()
{
    cout << "start wait sem..." << endl;
    sem_wait(&sem);
    cout << "end wait sem..." << endl;
}

void func_2_task()
{
    sleep(5);
    cout << "I will post sem" << endl;
    sem_post(&sem);
}

int main()
{
    sem_init(&sem, 0, 0);

    thread th_1(func_1_task);
    th_1.detach();

    thread th_2(func_2_task);
    th_2.detach();

	while (1)
    {
        sleep(10);
    }
    sem_destroy(&sem);
    return 0;
}

测试结果
在这里插入图片描述

原子变量atomic

  • 多线程编程中常用的同步机制，它能确保对共享变量的操作在执行时不被其它线程的操作干扰。
  • 保证操作是原子级别的，要么全部完成，要么全部未完成。
  • 原子类型：整形、指针、布尔值。语法：std::atomic< T >
  • 内存模型：通过指定memory orders实现线程安全
  • 多线程安全，效率比互斥量高

成员函数

is_lock_free()函数

  • 检查当前atomic对象是否支持无锁操作。

store()函数

  • 将给定的值存储到原子对象中。
  • 存储操作的内存顺序默认为：std::memory_order_seq_cst（顺序一致性）

load()函数

  • 获取原子变量的当前值。
  • 内存操作默认为：std::memory_order_seq_cst（顺序一致性）

exchange()函数

  • 替换并返回原来的值。

支持的基本操作总结

  • 加法：a += n 或 a.fetch_add(n)
  • 减法：a -= n 或 a.fetch_sub(n))
  • 自增：a++ 或 a.fetch_add(1)
  • 自减：a-- 或 a.fetch_sub(1)
  • 与：a &= b 或 a.fetch_add(b)
  • 或：a |= b 或 a.fetch_or(b)
  • 异或：a ^= b 或 a.fetch_xor(b)
  • 交换：a.exchange(b)

原子变量应用示例

多线程不加锁

static int g_total = 0;

void func_task()
{
    int i = 0;
    for (i = 1; i < 101; i++) {
        g_total += i;
        this_thread::sleep_for(chrono::milliseconds(100));
    }
}

int main()
{
    thread th_1(func_task);
    thread th_2(func_task);
    th_1.join();
    th_2.join();
    cout << "*** g_total: " << g_total << endl;

    return 0;
}

测试结果
在这里插入图片描述

多线程加锁

static int g_total = 0;
mutex mtx;

void func_task()
{
    int i = 0;
    for (i = 1; i < 101; i++) {
        {
            lock_guard<mutex> guard(mtx);
            g_total += i;
            this_thread::sleep_for(chrono::milliseconds(100));
        }
    }
}

int main()
{
    thread th_1(func_task);
    thread th_2(func_task);
    th_1.join();
    th_2.join();
    cout << "*** g_total: " << g_total << endl;
    
    return 0;
}

测试结果
在这里插入图片描述

多线程使用原子变量

//static int g_total = 0;
atomic<int> g_total(0);

void func_task()
{
    int i = 0;
    for (i = 1; i < 101; i++) {
         g_total += i;//或 total.fetch_add(i);
         this_thread::sleep_for(chrono::milliseconds(100));
    }
}

int main()
{
    thread th_1(func_task);
    thread th_2(func_task);
    th_1.join();
    th_2.join();
    cout << "*** g_total: " << g_total.load() << endl;

    return 0;
}

测试结果
在这里插入图片描述

原野风霜324
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C/C++ 多线程的学习心得总结
09-05
本篇文章是对C/C++中多线程的学习心得总结进行了详细的分析介绍，需要的朋友参考下
C++多线程讲解
顺其自然~专栏
06-02 6283
线程：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，进程包含一个或者多个线程。进程可以理解为完成一件事的完整解决方案，而线程可以理解为这个解决方案中的的一个步骤，可能这个解决方案就这只有一个步骤，也可能这个解决方案有多个步骤。 多线程：多线程是实现并发（并行）的手段，并发（并行）即多个线程同时执行，一般而言，多线程就是把执行一件事情的完整步骤拆分为多个子步骤，然后使得这多个步骤同时执行。 C++多线程：（简单情况下）C++多线程使用多个函数实现各自功能，然后将不同函数生成不同线程，并同时执行
c++的并发操作（多线程）和 while 优先级 已解决
最新发布
PHP代码的博客
01-29 902
C++11标准在标准库中为多线程提供了组件，这意味着使用C++编写与平台无关的多线程程序成为可能，而C++程序的可移植性也得到了有力的保证。另外，并发编程可提高应用的性能，这对对性能锱铢必较的C++程序员来说是值得关注的。 1. 何为并发 并发指的是两个或多个独立的活动在同一时段内发生。生活中并发的例子并不少，例如在跑步的时候你可能同时在听音乐；在看电脑显示器的同时你的手指在敲击键盘。这时我们称我们大脑并发地处理这些事件，只不过我们大脑的处理是有次重点的：有时候你会更关
C++网络编程踩坑记之多线程服务器，详解代码细节，多问为什么
踩坑博客
05-31 471
前置知识： 多线程知识 Socket编程 多线程并发服务器思路 lfd=socket()，创建监听套接字 lfd。 setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt, sizeof(opt))，设置端口复用。 bind()，绑定监听套接字lfd与Strcut scokaddr_in srv_addr(服务器IP和端口)。 listen()，把lfd转换成一个被动套接字，进入被动监听状态，用来被动接受来自其他主动套接字的连接请求，并设置监听上限。 主线程 w
java/C.C++线程while循环无法跳出问题分析
郭风朴(guofengpu)的Android影音专栏
05-20 1643
一、问题及现象
线程和while循环的关系
qq_54288071的博客
10-14 1315
线程和while循环的关系
多线程操作中为什么使用while而不是if来做判断状态是否就绪
weixin_30621959的博客
03-10 390
在多线程操作中，我们常常会遇到需要先判断信号量状态是否就绪，然后执行后续操作的场景。这里对状态的判断使用的是while而不是单线程下常用的if。 以下示例展示了一个简单的生产者-消费者模型：当队列满的时候，阻塞set；当队列为空的时候，阻塞get操作。 public class EventStorage { private int maxSize; private L...
多线程-线程锁-while循环
qq_40443457的博客
12-04 3933
今天写多线程遇到了几个问题，导致程序一直无法正常运行： 多个线程共用一个函数的时候，，由于没有用线程锁，导致无法正常运行； 函数中有while循环，加入多线程之后，，由于没有进行初始化互斥量，导致只有第一个线程起作用。 下面是例子： #include <stdio.h> #include <stdlib.h> #include <pthread.h> #in...
Java多线程中wait()为什么要放在while循环中
weixin_54869604的博客
03-13 1036
首先来执行一段代码 public class ThreadWaitNotifyDemo { public static void main(String[] args) { AirConditioner airConditioner = new AirConditioner(); new Thread(() ->{ for (int i = 0; i < 10; i++) { airCond
c++教学（8）while循环
Happy_potter_RD的博客
05-14 7495
计数器 while死循环 break。
c++的并发操作（多线程）
m0_74282605的博客
10-14 569
因此，并发重点指的是程序的设计结构，而并行指的是程序运行的状态。多个进程独立地运行，它们之间通过进程间常规的通信渠道传递讯息（信号，套接字，文件，管道等），这种进程间通信不是设置复杂就是速度慢，这是因为为了避免一个进程去修改另一个进程，操作系统在进程间提供了一定的保护措施，当然，这也使得编写安全的并发代码更容易。在这里，每个队列都有自己的安检窗口，两个队列中间没有竞争关系，队列中的某个排队者只需等待队列前面的人安检完成，然后再轮到自己安检。运行多个进程也需要固定的开销：进程的启动时间，进程管理的资源消耗。
JAVA多线程与并发学习总结分析
09-05
以下是对小编对JAVA多线程与并发的学习进行了总结介绍，需要的朋友可以过来参考下
C++-多线程编程总结-实例讲解.doc
10-10
C++-多线程编程总结-实例讲解.doc
C++多线程编程资料（容易理解）
04-17
整合了对C++多线程入门的总结和一些个人的理解，附加上具体实例，容易理解，是学习多线程编程的很好资料
[c/c++] 一个进程有多个线程，用什么方法让主线程不退出更好，要求占用资源最少，效率最高
程序猿的那些书
01-21 1734
[c/c++] 一个进程有多个线程，用什么方法让主线程不退出更好，要求占用资源最少，效率最高 我所知道的不让主线程退出的方法有: 一，死循环：while(1);/ for(;;); 二，pause(); 让主线程暂停等待信号使其退出 三，另一种死循环while(1)sleep(100) 四，通过信号量，使其通过等待一个不可能的发生的信号来阻塞，使main不退出。   问：还有哪
C++ 多线程详解（全网最全）
青春不老，奋斗不止！
05-31 2500
????推荐关注????在C++学习过程中，要想“更上一层楼”的话，多线程编程是必不可少的一步，前面的文章多半是基础方面的内容，这节的话稍微有点拔高。所以说，我们在看这篇文章的时候，大家需要更多的思考是为什么这么做？这样做的好处是什么？以及多线程编程都可以应用在哪里？话不多说，跟着我一起认真探讨这块内容。1、多线程传统的C++（C++11标准之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在...
C++多线程编程基础
Arcobaleno
02-08 369
本博转载于知乎：https://zhuanlan.zhihu.com/p/194198073 没想到我第一篇博客是哲学家就餐问题，涉及到多进程编程~ 事隔多年，我又开始折腾多线程编程。只是我真的奇怪，当时我是怎么做到的，写出了多进程的代码？那时的我真棒... 1 什么是C++多线程并发？ 线程：线程是操作系统能够进行CPU调度的最小单位，它被包含在进程之中，一个进程可包含单个或者多个线程。可以用多个线程去完成一个任务，也可以用多个进程去完成一个任务，它们的本质都相当于多个人去合伙完成一件事。 .
程序运行死机问题
modi000的博客
03-09 990
遇到问题： 程序中有多个线程，运行时装置死机； 原因： 某个线程中因为使用的是while(1)这个死循环，线程在不断的运行，抢占资源，导致死机； 解决方法： 在while循环中，使用sleep()函数。 ...
C++thread的使用(C++多线程相关）
昔拉的博客
01-13 5689
thread默认析构函数是调用了abort()让程序中止 子线程可以自己管理资源也可以在子线程结束时自动将线程杀死，需要程序员显示指定用的是哪种行为，一般都自己来管理资源由j.join()来结束线程 ...
如何系统性学习嵌入式多线程
04-01
学习嵌入式多线程需要掌握以下几个方面： 1. 嵌入式系统架构：了解嵌入式系统的硬件架构和软件架构，包括处理器、内存、总线、外设等。 2. 操作系统：学习嵌入式操作系统的基本概念、特点和应用，如FreeRTOS、uC/OS、Linux等。 3. 多线程编程：掌握多线程编程的基本概念、线程的创建、销毁、同步和通信方法，如互斥锁、信号量、消息队列等。 4. 嵌入式编程语言：熟练掌握C、C++等嵌入式编程语言的基本语法和特性，了解汇编语言的基本原理和操作方法。 5. 实践项目：通过实际项目的实践，深入理解嵌入式多线程编程的应用和实现方法，如嵌入式网络通信、控制系统等。 为了系统性地学习嵌入式多线程，可以参考以下步骤： 1. 学习嵌入式系统架构和操作系统的基本概念和应用，了解嵌入式系统的工作原理和常用的操作系统。 2. 学习多线程编程的基本概念和实现方法，了解线程同步和通信的方法和技巧。 3. 通过实际的例子和项目，深入理解嵌入式多线程编程的应用和实现方法，如网络通信、控制系统等。 4. 不断地实践和总结，积累经验和技能，提高嵌入式多线程编程的能力和水平。 总之，学习嵌入式多线程需要系统性和实践性相结合，需要不断地学习和实践，才能掌握嵌入式多线程编程的应用和实现方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值