多线程环境下，基本增减赋值操作的原子性实验[atomic,mutex]

最新推荐文章于 2025-06-08 10:26:24 发布

eric0095

最新推荐文章于 2025-06-08 10:26:24 发布

阅读量468

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/eric0095/article/details/50554414

在多线程环境下

int a=0;

(1)a++;

(2)--a;

(3)b+=2

(4)a=a+2

1.如果上面四个语句不加互斥访问，会出现问题的是？

实验结果：全部都可能。

2.用了如果a声明为atomic<int>呢？

实验结果：可以保证（1）（2）（3）不出问题，可以优化编译成一条机器指令。而（4）不会。

3.如果用了mutex呢，性能上的牺牲是什么样的？

实验结果：显然都不会出问题，但是性能上牺牲很大。测试10个线程跑100000次计算，用时约是仅用atomic语句的300多倍，是不加任何互斥保证的3000多倍。

结论：

1. 如果是a++,a--,--a,++a,b+=2这种类型的操作，一律用atomic保证即可，会优化为一句机器代码，高效且不会出错。

2.如果有b=b+2,之类的，改成b+=2,然后同1；如果是b=c+1这种，怎么优化也是多条机器语句，必须用mutex保证互斥

3.mutex互斥，对性能影响很大，而atomic性能影响很小。所以代码中能用atomic就放心用吧，而mutex小心用。很多情况下，充分利用指针和原子性，未必一定用mutex，很多问题都可以巧妙转化。

下面是一篇c++标准委员会的哥们的博客，作为参考。

ref：

http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=469

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

eric0095

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

25、C语言多线程编程全解析

m2n3b4v5c6的博客

07-02

本文全面解析了C语言中的多线程编程，涵盖多线程的基本概念、线程的创建与控制、共享数据的同步机制（包括互斥锁和原子操作），以及多线程编程中的常见问题和解决方法。文章还介绍了多线程编程的最佳实践和性能优化策略，并通过示例代码展示了如何综合运用这些技术开发高效稳定的多线程程序。

『 C++ 』多线程相关

小侯宝的博客

09-02

1309

但如果在最后的比较中,当前内存中的值与最初加载进寄存器中的值不同则表示这个值已经被其他线程修改过了,如果再把当前寄存器的值写回内存中则是一个无用功,会导致数据不一致问题,那么这次的CAS操作则是失败,此时需要重新将内存中的值加载进寄存器中并再次进行上述操作,当比较时当前内存中的值与原来加载进寄存器的值相同时才能把在寄存器中计算后的值写回内存中,才算一次CAS操作成功;但是这里的互斥锁有一个问题,由于临界资源很短,且对临界资源的操作是非常小的操作,使用互斥锁反而有种"杀鸡焉用牛刀"的感觉;

参与评论您还未登录，请先登录后发表或查看评论

多线程第二篇:多线程中的自加自减等原子操作

simply the best

12-15

1643

本文参考morewindows的博文仅仅稍加更改:http://blog.youkuaiyun.com/morewindows/article/details/7429155 我们再来深刻的看一下子线程之间竞争的例子: //线程报数的例子 #include #include #include int g_count = 0; unsigned int __stdcall ThreadFun(L

Atomic、Mutex性能测试

游戏猫的博客

07-10

777

一、结论 1、Atomic、Mutex相对于不加锁有较大的性能差别。 2、Mutex的性能开销是Atomic的两倍左右。二、测试代码 #pragma once #include <atomic> #include <thread> #include <chrono> using namespace std; class AtomicTest { private: atomic<long long> atomicCount=0; long long nor

C++多线程初探：thread、atomic及mutex的配合使用

yucicheung的博客

09-06

2014

多线程：原子操作解决线程冲突

【黑键】

03-24

984

转载自C++拾遗–多线程：原子操作解决线程冲突前言在多线程中操作全局变量一般都会引起线程冲突 1 线程冲突 #include <stdio.h> #include <stdlib.h> #include <process.h> #include <Windows.h> int g_count = 0; void count(void *p...

图文并茂Mutex性能问题解析

03-02

图文并茂Mutex性能问题解析，理解Mutex的机制，对于理解共享池的争用，意义巨大

【C++高级编程】第三章：并发与多线程编程（Concurrency & Multi-threading Programming）

u012133341的博客

06-08

1027

本文详细介绍了C++11及更高版本中的并发编程技术，主要包括四个核心内容：1) 线程管理与同步原语，包括线程创建、互斥量、条件变量和读写锁；2) 原子操作与无锁编程，深入讲解std::atomic和内存序；3) 异步编程模型，涵盖std::future、std::promise和std::async；4) 线程池实现与优化。通过示例代码展示了生产者-消费者模型、无锁队列等典型应用，并提供了线程池设计的最佳实践，帮助开发者构建高性能并发应用。文章强调多核处理器时代并发编程的重要性，为C++开发者提供了全面的并

【并发控制】：四人抢答器中的多线程编程与数据一致性解决方案

![四人智力竞赛抢答器课程设计](https://img-blog.csdnimg.cn/20200918182613487.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwNzU5NTg1,size... ...

C++线程局部存储详解：std::atomic与内存模型的高级应用

线程局部存储（Thread Local Storage, TLS）是一种为每个线程提供独立的变量存储的技术，它保证了每个线程都有自己的变量副本，从而在多线程环境下避免了数据竞争的问题。理解线程局部存储的基础概念对于掌握并

多线程编程中整型变量的赋值

Li_Charles的博客

12-22

915

多线成编程

C++ mutex和std::atomic性能比较

dreamtale90的博客

06-26

4798

C++ mutex和std::atomic性能比较使用mutex进行访问控制，mutex.c //方案1：mutex锁保证线程安全 #include<thread> #include<iostream> #include<mutex> using namespace std; mutex m; const int N=1e6; int n; void ...

转.关于x86_64架构下atomic、mutex、rwlock的性能对比

boshi_liu的博客

06-13

384

转.关于x86_64架构下atomic、mutex、rwlock的性能对比转载请注明出处：http://forever.blog.chinaunix.net

并发，std::atomic 和 std::mutex 区别

weixin_33853827的博客

11-18

367

2019独角兽企业重金招聘Python工程师标准>>> ...

浅谈Mutex (Lock)

木牛的博客

08-31

2万+

Mutex(又叫 Lock),在多线程中,作为同步的基本类型,用来保证没有两个线程或进程同时在他们的关键区域.因为 Mutex 这种排它性,很多人认为 Mutex 开销很大,尽量避免使用它.就如这篇分析完共享数据问题后,进一步分析说明Avoiding locks来解决这个问题.但 Mutex 真的开销如此大,还是被大家误解了?Matthew Dillon写道,”Most people have the misconception that locks are slow.”, Jeff Preshing...

c++ 原子操作赋值_多线程操作可见性

weixin_39708708的博客

12-07

558

可见性：让一个线程对共享变量的修改，能够及时的被其他线程看到，java中首先想到的就是volatilevolatile关键字Java内存模型中规定：1.对某个volatile 字段的写操作happens-before 每个后续对该volatile 字段的读操作。2.对volatile 变量v 的写入，与所有其他线程后续对v 的读同步。volatile如何实现它的语义？1.禁止缓存；volatile...

并发编程四-原子操作（比较并替换CAS操作）

baidu_32689899的博客

06-15

1026

Java中除了synchronized修饰的代码来保证原子性之外，还有其他方式可以用来保证原子性操作。其中CAS操作就保证了原子性，在JVM层解决并发访问的问题。

C++11中的原子操作（atomic operation）

最新发布

07-16

<think>首先，用户的问题是关于C++中shared_ptr的线程安全性。他们想知道shared_ptr是否线程安全，以及在多线程环境下的使用注意事项。从系统级指令中，我需要： - 使用$...$格式表示行内数学表达式（但这里可能不需要数学表达式）。 - 独立公式用$$...$$格式（同样，可能不适用）。 - LaTeX语法正确（确保代码块正确）。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾添加引用标识，如[^1]。 - 回答结构清晰，逐步解决问题。 - 参考提供的引用，确保回答真实可靠。提供的引用： - [^1]: shared_ptr的线程安全性从三个并发场景考虑：拷贝、赋值、读写指向内存。 - [^2]: 引用计数操作是线程安全的；访问指向对象需要额外同步；直接修改shared_ptr对象本身在多线程中不安全。 - [^3]: 引用计数和weak计数是原子操作；shared_ptr只读时线程安全；操作被管理对象需要锁；同一个shared_ptr对象被多个线程修改时（如reset）不安全。 - [^4]: 不安全操作：同一shared_ptr实例的修改需要加锁；指向对象的访问需要用户同步。 - [^5]: 读取同一个shared_ptr实例是线程安全；修改同一个实例需要同步。用户的问题核心：shared_ptr对象本身的线程安全性问题，以及多线程使用注意事项。我的回答结构： 1. **引言**：简要介绍shared_ptr和线程安全概念。 2. **线程安全性的分析**：基于引用，分点讨论。 - 引用计数的线程安全性。 - shared_ptr对象本身（如拷贝、赋值、reset）的线程安全性。 - 访问指向对象的线程安全性。 3. **多线程使用注意事项**：总结建议。 4. **生成相关问题**：在末尾添加相关问题。确保添加引用标识：在引用段落末尾加[^1]、[^2]等。最后，生成相关问题。回答大纲： - 开头：解释shared_ptr的基本功能。 - 主体：逐步分析线程安全性。 - 引用计数：原子操作，线程安全。 - shared_ptr对象本身：修改时需要同步。 - 指向对象：需要额外同步。 - 注意事项：给出实用建议。 - 结尾：相关问题。使用中文。</think>### C++ shared_ptr 线程安全性分析在C++中，`std::shared_ptr` 是一个智能指针，用于管理对象的生命周期，通过引用计数自动释放资源。用户询问其线程安全性问题，特别是`shared_ptr`对象本身在多线程环境下的行为。线程安全性取决于具体操作场景：并非所有操作都是线程安全的。我将基于权威资料和C++标准，逐步分析线程安全性的关键点，并提供多线程使用注意事项。 #### 1. **shared_ptr 线程安全性的分场景分析** - **引用计数操作是线程安全的**： `shared_ptr`的引用计数（包括weak计数）使用原子操作实现，因此在多线程中，引用计数的增减（如拷贝或析构）是线程安全的。这意味着多个线程可以同时创建或销毁指向同一对象的`shared_ptr`副本，而不会导致计数错误或资源泄漏[^1][^2][^3]。例如： ```cpp // 线程安全的操作：在不同线程中拷贝shared_ptr副本 std::shared_ptr<int> ptr1 = std::make_shared<int>(42); // 线程A std::thread t1([ptr1] { auto ptr2 = ptr1; // 拷贝操作，引用计数原子增加 }); // 线程B std::thread t2([ptr1] { auto ptr3 = ptr1; // 拷贝操作，引用计数原子增加 }); ``` 此操作安全，因为引用计数的修改是原子的[^2][^3]。 - **shared_ptr对象本身的修改不是线程安全的**：如果多个线程直接对同一个`shared_ptr`对象（非副本）进行写操作，如赋值、`reset()`或移动，则会导致数据竞争和未定义行为。例如，线程A调用`reset()`改变指针指向，同时线程B读取或修改同一个`shared_ptr`对象，这需要用户自行加锁来同步[^3][^4][^5]： ```cpp std::shared_ptr<int> ptr = std::make_shared<int>(100); std::mutex mtx; // 线程A：修改ptr（不安全，需要加锁） std::thread t1([&] { std::lock_guard<std::mutex> lock(mtx); // 必须加锁 ptr.reset(new int(200)); // 重置指针 }); // 线程B：读取ptr（不安全，需要加锁） std::thread t2([&] { std::lock_guard<std::mutex> lock(mtx); // 必须加锁 if (ptr) { // 读取指针状态 // 操作 } }); ``` 如果不加锁，同一`shared_ptr`对象的并发修改可能引发崩溃或内存错误[^4][^5]。 - **访问指向的对象不是线程安全的**： `shared_ptr`只管理指针的生命周期，并不保证指向的对象是线程安全的。如果多个线程访问或修改被管理对象（如通过`operator*`或`operator->`），用户必须使用互斥锁或其他同步机制来保护对象数据[^1][^2][^4]。例如： ```cpp struct Data { int value = 0; }; auto data_ptr = std::make_shared<Data>(); std::mutex data_mtx; // 线程A：修改对象 std::thread t1([&] { std::lock_guard<std::mutex> lock(data_mtx); data_ptr->value = 10; // 需要同步 }); // 线程B：读取对象 std::thread t2([&] { std::lock_guard<std::mutex> lock(data_mtx); std::cout << data_ptr->value; // 需要同步 }); ``` 此场景下，`shared_ptr`本身不提供任何保护，用户需负责对象访问的线程安全[^3][^5]。 #### 2. **多线程环境下使用注意事项** - **安全操作**： - 在多个线程中共享`shared_ptr`副本是安全的（引用计数原子操作）。 - 只读访问同一个`shared_ptr`对象的const成员函数（如`use_count()`）是线程安全的[^5]。 - **不安全操作及应对措施**： - 避免直接修改同一个`shared_ptr`对象：使用`std::mutex`或`std::atomic`来同步写操作。例如，将`shared_ptr`封装在互斥锁保护的结构中。 - 访问指向对象时：必须为对象本身添加同步机制，如互斥锁或原子变量。 - 性能考虑：频繁加锁可能影响性能，考虑使用`std::atomic<std::shared_ptr>`（C++20起支持）或线程本地存储来减少竞争[^2][^4]。 - **最佳实践**： - 优先传递`shared_ptr`副本，而非共享同一个对象实例。 - 使用`std::weak_ptr`来打破循环引用，避免引用计数问题。 - 在关键代码段进行压力测试，确保无数据竞争。总结：`std::shared_ptr`的引用计数机制是线程安全的，但`shared_ptr`对象本身的修改和指向对象的访问需要用户手动同步[^1][^2][^3][^4][^5]。在多线程环境中，应谨慎设计以避免竞争条件。