std::atomic

最新推荐文章于 2024-07-30 15:00:10 发布
最新推荐文章于 2024-07-30 15:00:10 发布
阅读量3.2k 收藏 26
点赞数 24
分类专栏： # 标准库日常 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kenfan1647/article/details/135717780
版权
本文介绍了C++11中的std::atomic类及其在多线程环境下的应用，包括原子操作、比较和交换函数、fetch方法以及如何使用std::atomic_ref处理非原子变量。通过实例展示了如何使用这些工具避免数据竞争和竞态条件。
摘要由CSDN通过智能技术生成

一、概述

std::atomic 是C++11引入的一个模板类，用于提供原子操作的类型。在多线程编程中，当多个线程同时访问同一块数据时，可能会导致数据竞争和不确定的行为。std::atomic 可以用来创建原子类型的变量，保证对该变量的操作是原子的，不会被中断，从而避免了数据竞争。

std::atomic 适用于以下场景：

  1. 在多线程环境下对共享数据进行原子操作；
  2. 需要保证特定操作的原子性，如递增、递减、交换等操作；
  3. 需要避免使用锁的情况下进行线程同步。

举个具体的例子：

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

int counter = 0;

void incrementCounter()
{
    for (int i = 0; i < 100000; ++i)
    {
        counter++;
    }
}

int main(int argc, char *argv[])
{
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);

    t1.join();
    t2.join();

    qDebug() << counter;

    return 0;
}

这段代码存在一个线程安全的问题。多个线程同时访问和修改同一个全局变量 counter ，而没有进行同步操作会导致竞态条件。

竞态条件指的是多个线程并发执行时，由于执行顺序不确定导致程序出现意料之外的结果的情况。

就上面的代码来说，在 incrementCounter() 函数中，多个线程同时对 counter 进行递增操作，而递增操作不是一个原子操作，它包括读取 counter 的当前值、对该值加一、然后写回到 counter。由于线程间的执行顺序是不确定的，就可能出现以下情况：

  1. 线程 A 读取 counter 的值为 0，然后执行加一操作得到 1；
  2. 此时线程 B 也读取 counter 的值为 0，执行加一操作得到 1；
  3. 然后线程 A 和线程 B 都把值 1 写回到 counter，导致实际的递增次数少于预期。

因此，竞态条件可能会导致 counter 的最终结果少于预期的值。

为了解决这个问题，可以使用互斥锁来保护对 counter 的访问，确保同时只有一个线程能够访问和修改 counter，从而避免了竞态条件的问题：

int counter = 0;
std::mutex mutex;

void incrementCounter()
{
    for (int i = 0; i < 100000; ++i)
    {
        std::lock_guard<std::mutex> lock(mutex);
        counter++;
    }
}

int main(int argc, char *argv[])
{
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);

    t1.join();
    t2.join();

    qDebug() << counter;

    return 0;
}

使用std::atomic是另一种做法：

#include <atomic>

std::atomic<int> counter(0);

void incrementCounter()
{
    for (int i = 0; i < 100000; ++i)
    {
        counter++;
    }
}

int main(int argc, char *argv[])
{
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);

    t1.join();
    t2.join();

    qDebug() << counter;

    return 0;
}

使用std::atomic<int> 类型的计数器 counter，并在两个线程中并发地对其进行递增操作。由于 counter 是 std::atomic 类型，它会保证递增操作的原子性，避免了多线程竞争导致的问题。最终输出的 counter 值会是预期的 200000。

二、成员函数

1、compare_exchange_weak()、compare_exchange_strong()

比较和交换函数。这两个函数的作用都是：当原子对象的值等于期望值时，用新值替换原子对象的值。

compare_exchange_weak 函数

  • 比较和交换不成功时，允许原子变量的值被其他线程更改，并返回 false，表示失败。
  • 比较和交换成功时，将原子变量的值设置为新值，并返回 true，表示成功。
std::atomic<int> atomic_var(10);

void increment(std::atomic<int>& var)
{
    int expected = 10;
    int new_value = 20;

    bool success = var.compare_exchange_weak(expected, new_value);

    if (success) {
        std::cout << "线程 " << std::this_thread::get_id()<< std::endl
                  << " 比较和交换成功，原子变量的值已修改为: " << var << std::endl;
    } else {
        std::cout << "线程 " << std::this_thread::get_id()<< std::endl
                  << " 比较和交换失败，原子变量的值未修改" << std::endl;
    }
}

int main(int argc, char *argv[])
{
    std::thread t1(increment, std::ref(atomic_var));
    std::thread t2(increment, std::ref(atomic_var));
    t1.join();
    t2.join();
    return 0;
}

如果某个线程在比较和交换时发现 atomic_var 的值已经被其他线程更改，那么它会允许原子变量的值被其他线程更改，并返回 false，表示失败。因此，上面代码输出结果可能会是以下两种情况之一：

结果1

线程 1 比较和交换成功，原子变量的值已修改为: 20

线程 2 比较和交换失败，原子变量的值未修改

结果2

线程 2 比较和交换失败，原子变量的值未修改

线程 1 比较和交换成功，原子变量的值已修改为: 20

compare_exchange_strong 函数

  • 比较和交换不成功时，拒绝其他线程对原子变量的更改，并返回 false，表示失败。
  • 比较和交换成功时，将原子变量的值设置为新值，并返回 true，表示成功。
std::atomic<int> atomic_var(10);

void increment(std::atomic<int>& var)
{
    int expected = 10;
    int new_value = 20;

    bool success = var.compare_exchange_strong(expected, new_value);

    if (success) {
        std::cout << "线程 " << std::this_thread::get_id()<< std::endl
                  << " 比较和交换成功，原子变量的值已修改为: " << var << std::endl;
    } else {
        std::cout << "线程 " << std::this_thread::get_id()<< std::endl
                  << " 比较和交换失败，原子变量的值未修改" << std::endl;
    }
}

int main(int argc, char *argv[])
{
    std::thread t1(increment, std::ref(atomic_var));
    std::thread t2(increment, std::ref(atomic_var));
    t1.join();
    t2.join();
    return 0;
}

如果某个线程在比较和交换时发现 atomic_var 的值已经被其他线程更改，那么它会拒绝其他线程对原子变量的更改，并返回 false，表示失败。因此，无论哪个线程先执行，只会有一个线程能够成功修改原子变量的值。上述代码输出结果可能会是以下两种情况之一：

结果1

线程 1 比较和交换成功，原子变量的值已修改为: 20

线程 2 比较和交换失败，原子变量的值未修改

结果2

线程 2 比较和交换成功，原子变量的值已修改为: 20

线程 1 比较和交换失败，原子变量的值未修改

2、exchange()

原子地交换原子变量的值，并返回原来的值。

    std::atomic<int> atomic_var(10);

    // 将 atomic_var 的值交换为 42
    int old_value = atomic_var.exchange(42);

    std::cout << "旧值: " << old_value << std::endl;
    std::cout << "新值: " << atomic_var << std::endl;

3、fetch_add()、fetch_sub()

原子地将原子变量的值增加 / 减少指定的增量，并返回增加前的旧值。

    std::atomic<int> atomic_var(10);

    // 将 atomic_var 的值原子地增加 5
    int old_value = atomic_var.fetch_add(5);

    std::cout << "增加前的值: " << old_value << std::endl;
    std::cout << "增加后的值: " << atomic_var << std::endl;

4、fetch_and()、fetch_or()、fetch_xor()

原子地将原子变量的值与指定的值进行按位 与 / 或 / 异或 操作，并返回按位与前的旧值。

5、load()、operator T()

获取对象中存储的值，同时确保在多线程环境下进行安全的原子操作（也就是可以安全地在多线程环境下进行，而无需额外的同步控制）。

std::atomic<int> atomicInt(42);
int value = atomicInt.load();//value = 42;

6、store()

用于将给定的值存储到std::atomic对象中，并确保在多线程环境下进行安全的原子操作。该函数没有返回值，它仅负责将值存储到std::atomic对象中。它确保在存储新值之前，不会发生其他线程访问该std::atomic对象的竞争条件。

三、一个自定义类型的示例

std::atomic 不仅支持数值类型，还支持其他可赋值类型。

#include <iostream>
#include <thread>
#include <atomic>
#include <string>

struct Person {
    std::string name;
    int age;
};

std::atomic<Person> atomicPerson;

void updatePerson() {
    Person p{"Alice", 25};
    atomicPerson.store(p);
}

void printPerson() {
    Person p = atomicPerson.load();
    std::cout << "Name: " << p.name << ", Age: " << p.age << std::endl;
}

int main() {
    std::thread t1(updatePerson);
    std::thread t2(printPerson);

    t1.join();
    t2.join();

    return 0;
}

四、std::atomic_ref

此模板类可以对各种类型的非原子变量进行原子操作，比如整型、指针、自定义结构等。它允许在需要时对非原子变量进行原子操作。

在多线程环境中使用 std::atomic_ref 可以避免对非原子变量进行竞争条件的操作，从而提高线程安全性。

此类也有如上述的成员函数。

例1：

    int value = 42;
    std::atomic_ref<int> atomicValue(value);

    atomicValue.store(10, std::memory_order_relaxed);
    std::cout << "Value is: " << value << std::endl; // 输出 10

这里首先创建了一个普通的整型变量 value，然后使用 std::atomic_ref 类型的 atomicValue 对其进行原子操作。通过 store 函数，将新的值 10 存储到 atomicValue 中，这也直接影响到了原始的变量 value。

例2：

#include <iostream>
#include <atomic>
#include <string>

struct UserData 
{
    std::string name;
    int age;
};

int main(int argc, char *argv[])
{
    UserData user {"Alice", 30};

    std::atomic_ref<int> atomicAge(user.age);

    // 在多线程环境中，使用原子操作更新用户的年龄
    auto updateAge = [&atomicAge](int newAge)
    {
        atomicAge.store(newAge, std::memory_order_relaxed);
    };

    std::thread t1(updateAge, 35);
    std::thread t2(updateAge, 40);

    t1.join();
    t2.join();

    std::cout << "Updated user1's age: " << user.age << std::endl; // 输出更新后的年龄

    return 0;
}

这里使用 std::atomic_ref 类型的 atomicAge 对 user 结构体中的 age 成员变量进行原子操作。在 updateAge 函数中，将新的 age 值存储到 atomicAge 中，并利用 std::thread 创建了两个线程来更新 user 的 age 。

友善啊，朋友
关注
  • 24
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
探索C++并发容器：std::atomic
夏天的狂风的专栏
06-10 488
在C++中，是一个模板类，它提供了一种执行原子操作的方式。原子操作是不可分割的，也就是说，在执行过程中不会被其他线程打断。可以用于任何可复制赋值的类型，包括整数类型、浮点类型、指针类型等。提供了一系列的成员函数，包括loadstoreexchange等，它们都是原子的，也就是说，在执行过程中不会被其他线程打断。是C++中处理原子操作的一个重要工具。你可以通过来执行一系列的原子操作，包括loadstoreexchange等。你还可以通过来实现更复杂的并发编程模式，例如自旋锁。
error: use of deleted function ‘std::atomic＜int＞::atomic(const std::atomic＜int＞&) 防止原子类型被意外复制
usstmiracle的博客
01-26 986
编译错误是因为你使用了被删除的拷贝构造函数`std::atomic::atomic(const std::atomic&)`，它用来防止原子类型被意外复制。`，它们不会调用拷贝构造函数，而是调用其他的构造函数，如`constexpr atomic(__integral_type __i) noexcept`。这样就可以解决你的错误，让你的程序正常编译和运行。这就会调用被删除的拷贝构造函数，导致错误。上面代码中，你使用了拷贝初始化的语法`可以使用直接初始化的语法``或者列表初始化的语法`
深入理解并掌握C++ std::atomic 原子操作 的实用技巧与应用
最新发布
苦逼的程序猿☺
07-30 441
std::atomic_bool是std::atomic的类型别名，这意味着它们是完全相同的类型。在C++标准库中，为了方便使用，为一些常用的类型提供了类型别名，例如std::atomic_int是std::atomic的类型别名，std::atomic_long是std::atomic的类型别名，等等。例如，对于std::atomic或std::atomic，只有load()和store()等操作是原子的，而对于std::atomic或std::atomic等整数类型，所有操作都是原子的。
C++11：atomic原子操作
燃犀的博客
02-29 732
使其具备原子操作的特性。使用 std::atomic 声明的变量可以通过成员函数调用来进行原子操作，如加载（load）、存储（store）、交换（exchange）、比较与交换（compare_exchange_weak/compare_exchange_strong）等。使用 std::atomic 可以有效地确保对共享数据的正确性和一致性，避免数据竞争和并发问题，提供了一种可靠的方式来处理多线程环境下的并发操作。
c++原子操作 std::atomic
xie__jin__cheng的博客
05-10 756
c++原则操作 std::atomic
C++并发之原子操作(std::atomic)
flysnow010的博客
06-17 1067
原子类型是封装一个值的类型，该值的访问保证不会导致数据争用，并且可以用于同步不同线程之间的内存访问。这个头文件(atomic)声明了两个C++类，atomic和atomic_flag，它们在自包含类中实现原子类型的所有特性。头文件(atomic)还声明了一整套与C中的原子支持兼容的C样式类型和函数。
C++并发编程 | 原子操作std::atomic
weixin_44479862的博客
11-27 1万+
C++并发编程 | 原子操作std::atomic
原子操作（线程并发）（std::atomic）
qq_49190652的博客
05-06 850
原子操作详解
【C++11并发】何为std::atomic,其原理如何，以及使用注意事项
weixin_42157432的博客
04-09 8817
对原子类型的某些操作不一定是线程安全的，比如说 a=a+12; 非线程安全 a+=12; 线程安全 分析如下 Cppreference介绍 成员函数（原子操作） is_lock_free store 用非原子参数替换原子对象的值 load 获取原子对象的值 exchange 交换两个原子对象的值 wait 阻塞线程，直到收到通知并且原子值发生变化 notify_one 通知至少一个线程在等待原子对象 notify_all 通知所有阻塞的线程等待原.
std::atomic_flag
yusheng_bo的博客
02-06 502
摘要 原型: struct atomic_flag; Atomic flags是boolean atomic 对象, 支持两种操作, test-and-set 和 clear. Atomic flags是 lock-free(原子操作), 是唯一被保证的lock-free 原子操作的. Constructor atomic_flag() noexcept = default; atom...
【C++】std::atomic
静谧、淡雅
06-28 1043
原子操作：指”不可分割的操作“。一个操作的状态要么就是未执行, 要么就是已完成。 ​ 在多个线程访问同一个全局资源的时候，能够确保所有其他的线程都不在同一时间内访问相同的资源。也就是确保了在同一时刻只有唯一的线程对这个资源进行访问。 原子操作更加接近底层，因而效率更高。 std::atomic_bool 和 std::atomic_int。 std::atomic 写(存储)操作是通过store来完成的。 例如： std::atomic_int Test_Count; ......
C++ 中的原子变量（std::atomic）使用指南
qq_46017342的博客
09-12 1万+
C++ 中的原子变量（std::atomic）使用指南
C++(26): 原子操作（std::atomic）
tecsai的博客
06-21 1256
开发过多线程、并发编程的小伙伴一定接触过mutex，通过对资源进行加锁和解锁，实现对方问和修改的互斥操作。mutex使用起来很方便，很强大，但也有局限性。频繁地加锁和解锁会造成较大的资源消耗，影像系统的性能。 与mutex相比，原子（atomic）操作相对灵活和简单。 注意，这种灵活性在一定程度上是做了某些妥协的。
c++11：std::atomic
热门推荐
李白
11-01 2万+
std::atomic<T>::load定义 T load( std::memory_order order = std::memory_order_seq_cst ) const noexcept; c++11起 T load( std::memory_order order = std::memory_order_seq_cst ) const volatile noexcept; 原子地加载，并返回原子变量当前的值，按照order...
std::atomic原子
bkhyv的博客
07-23 912
std::atomic原子操作
std::atomic<>
10-13
std::atomic<> 是 C++11 中引入的一个原子类型，用于实现多线程中的原子操作。它可以保证在多线程环境下对变量的读写操作是原子的，即不会被其他线程打断。 使用 std::atomic<> 可以避免多线程环境下的数据竞争问题，从而提高程序的并发性能。 例如，下面的代码演示了如何使用 std::atomic<> 实现一个计数器： ``` #include <atomic> #include <iostream> #include <thread> std::atomic<int> counter(0); void increment_counter() { for (int i = 0; i < 1000000; ++i) { counter++; } } int main() { std::thread t1(increment_counter); std::thread t2(increment_counter); t1.join(); t2.join(); std::cout << "Counter value: " << counter << std::endl; return 0; } ``` 输出结果为： ``` Counter value: 2000000 ``` 可以看到，使用 std::atomic<> 可以避免多线程环境下的计数器竞争问题，从而得到正确的计数结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值