C++ 并发指南 std::atomic

最新推荐文章于 2024-06-21 11:43:19 发布
最新推荐文章于 2024-06-21 11:43:19 发布
阅读量3.3k 收藏 10
点赞数 4
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24649627/article/details/114366823
版权

std::atomic 基本介绍

std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。

template struct atomic;

原子类型对象的主要特点就是从不同线程访问不会导致数据竞争(data race)。因此从不同线程访问某个原子对象是良性 (well-defined) 行为，而通常对于非原子类型而言，并发访问某个对象（如果不做任何同步操作）会导致未定义 (undifined) 行为发生。

std::atomic 构造函数

std::atomic 的构造函数如下：
在这里插入图片描述

  1. 默认构造函数，由默认构造函数创建的 std::atomic 对象处于未初始化(uninitialized)状态，对处于未初始化(uninitialized)状态 std::atomic对象可以由 atomic_init 函数进行初始化。
  2. 初始化构造函数，由类型 T初始化一个 std::atomic对象。
  3. 拷贝构造函数被禁用。

请看下例：

#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT
#include <thread>         // std::thread, std::this_thread::yield
#include <vector>         // std::vector
 
// 由 false 初始化一个 std::atomic<bool> 类型的原子变量
std::atomic<bool> ready(false);
std::atomic_flag winner = ATOMIC_FLAG_INIT;
 
void do_count1m(int id)
{
    while (!ready) { 
        std::this_thread::yield();  // 等待 ready 变为 true.
    }
    
    for (volatile int i=0; i<1000000; ++i) {} // 计数
 
    if (!winner.test_and_set()) {
      std::cout << "thread #" << id << " won!\n";
    }
}
 
int main ()
{
    std::vector<std::thread> threads;
    std::cout << "spawning 10 threads that count to 1 million...\n";
    
    for (int i=1; i<=10; ++i) 
        threads.push_back(std::thread(do_count1m,i));
        
    ready = true;
 
    for (auto& th : threads) 
        th.join();
        
    return 0;
}

std::atomic::operator=() 函数

std::atomic 的赋值操作函数定义如下：
在这里插入图片描述
可以看出，普通的赋值拷贝操作已经被禁用。但是一个类型为 T 的变量可以赋值给相应的原子类型变量（相当与隐式转换），该操作是原子的，内存序(Memory Order) 默认为顺序一致性(std::memory_order_seq_cst)，如果需要指定其他的内存序，需使用 std::atomic::store()。

#include <iostream>             // std::cout
#include <atomic>               // std::atomic
#include <thread>               // std::thread, std::this_thread::yield
 
std::atomic<int> foo(0);
 
void set_foo(int x)
{
    foo = x; // 调用 std::atomic::operator=().
}
 
void print_foo()
{
    while (foo == 0) { // wait while foo == 0
        std::this_thread::yield();
    }
    std::cout << "foo: " << foo << '\n';
}
 
int main()
{
    std::thread first(print_foo);
    std::thread second(set_foo, 10);
    
    first.join();
    second.join();
    
    return 0;
}

基本 std::atomic 类型操作

is_lock_free

bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;

判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足 lock-free 特性，在多个线程访问该对象时不会导致线程阻塞。(可能使用某种事务内存transactional memory 方法实现 lock-free 的特性)。

store

void store (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
void store (T val, memory_order sync = memory_order_seq_cst) noexcept;

修改被封装的值，std::atomic::store 函数将类型为 T 的参数 val 复制给原子对象所封装的值。T 是 std::atomic 类模板参数。另外参数 sync 指定内存序(Memory Order)，可能的取值如下：
在这里插入图片描述
请看下面例子：

#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread
 
std::atomic<int> foo(0);  // 全局的原子对象 foo
 
void set_foo(int x)
{
    foo.store(x, std::memory_order_relaxed);     // 设置(store) 原子对象 foo 的值
}
 
void print_foo()
{
    int x;
    do {
        x = foo.load(std::memory_order_relaxed); // 读取(load) 原子对象 foo 的值
    } while (x == 0);
    
    std::cout << "foo: " << x << '\n';
}
 
int main ()
{
    std::thread first(print_foo);     // 线程 first 打印 foo 的值
    std::thread second(set_foo, 10);  // 线程 second 设置 foo 的值
    
    first.join();
    second.join();
    
    return 0;
}

load

T load (memory_order sync = memory_order_seq_cst) const volatile noexcept;
T load (memory_order sync = memory_order_seq_cst) const noexcept;

读取被封装的值，参数 sync 设置内存序(Memory Order)，可能的取值如下：
在这里插入图片描述
请看上面store例子。

operator T

operator T() const volatile noexcept;
operator T() const noexcept;

与 load 功能类似，也是读取被封装的值，operator T() 是类型转换(type-cast)操作，默认的内存序是 std::memory_order_seq_cst，如果需要指定其他的内存序，应该使用 load() 函数。
请看下面例子：

#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread, std::this_thread::yield
 
std::atomic<int> foo(0);
std::atomic<int> bar(0);
 
void set_foo(int x)
{
    foo = x;
}
 
void copy_foo_to_bar()
{
 
    // 如果 foo == 0，则该线程 yield,
    // 在 foo == 0 时, 实际也是隐含了类型转换操作,
    // 因此也包含了 operator T() const 的调用.
    while (foo == 0) 
        std::this_thread::yield();
 
    // 实际调用了 operator T() const, 将foo 强制转换成 int 类型,
    // 然后调用 operator=().
    bar = static_cast<int>(foo);
}
 
void print_bar()
{
    // 如果 bar == 0，则该线程 yield,
    // 在 bar == 0 时, 实际也是隐含了类型转换操作,
    // 因此也包含了 operator T() const 的调用.
    while (bar == 0) 
        std::this_thread::yield();
    std::cout << "bar: " << bar << '\n';
}
 
int main ()
{
    std::thread first(print_bar);
    std::thread second(set_foo, 10);
    std::thread third(copy_foo_to_bar);
 
    first.join();
    second.join();
    third.join();
    return 0;
}

exchange

T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept;

读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。
sync参数指定内存序(Memory Order)，可能的取值如下：
在这里插入图片描述
请看下面例子，各个线程计数至 1M，首先完成计数任务的线程打印自己的 ID，

#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector
 
std::atomic<bool> ready(false);
std::atomic<bool> winner(false);
 
void count1m (int id)
{
    while (!ready) {}                      // wait for the ready signal
    for (int i = 0; i < 1000000; ++i) {}   // go!, count to 1 million
    
    if (!winner.exchange(true)) { 
        std::cout << "thread #" << id << " won!\n"; 
    }
};
 
int main ()
{
    std::vector<std::thread> threads;
    std::cout << "spawning 10 threads that count to 1 million...\n";
    
    for (int i = 1; i <= 10; ++i) 
        threads.push_back(std::thread(count1m,i));
    
    ready = true;
    
    for (auto& th : threads) 
        th.join();
 
    return 0;
}

compare_exchange_weak

在这里插入图片描述
比较并交换被封装的值(weak)与参数 expected 所指定的值是否相等，如果：

  • 相等，则用 val 替换原子对象的旧值。
  • 不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。

该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于 expected)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。

在第(2)种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于 expected)，则选择参数 success 指定的内存序，否则选择参数 failure 所指定的内存序。

注意，该函数直接比较原子对象所封装的值与参数 expected 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare_exchange_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。

与compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允许原子对象所封装的值与参数 expected 的物理内容相同，但却仍然返回 false，不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare_exchange_weak 的性能更好 。如果 compare_exchange_weak 的判断确实发生了伪失败(spurious failures)——即使原子对象所封装的值与参数 expected 的物理内容相同，但判断操作的结果却为 false，compare_exchange_weak函数返回 false，并且参数 expected 的值不会改变。

对于某些不需要采用循环操作的算法而言, 通常采用compare_exchange_strong 更好。另外，该函数的内存序由 sync 参数指定，可选条件如下：
在这里插入图片描述
请看下面的例子：

#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector
 
// a simple global linked list:
struct Node { 
    int value; 
    Node* next; 
};

std::atomic<Node*> list_head(nullptr);
 
void append(int val)
{
    // append an element to the list
    Node* newNode = new Node{val, list_head};
 
    // next is the same as: list_head = newNode, but in a thread-safe way:
    while (!list_head.compare_exchange_weak(newNode->next,newNode)) {}
    // (with newNode->next updated accordingly if some other thread just appended another node)
}
 
int main ()
{
    // spawn 10 threads to fill the linked list:
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) 
        threads.push_back(std::thread(append, i));
        
    for (auto& th : threads) 
        th.join();
 
    // print contents:
    for (Node* it = list_head; it!=nullptr; it=it->next)
        std::cout << ' ' << it->value;
 
    std::cout << '\n';
 
    // cleanup:
    Node* it; 
    while (it=list_head) {
        list_head=it->next; 
        delete it;
    }
 
    return 0;
}

compare_exchange_strong

在这里插入图片描述
比较并交换被封装的值(strong)与参数 expected 所指定的值是否相等，如果：

  • 相等，则用 val 替换原子对象的旧值。
  • 不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。

该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于 expected)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。

在第(2)种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于 expected)，则选择参数 success 指定的内存序，否则选择参数 failure 所指定的内存序。

注意，该函数直接比较原子对象所封装的值与参数 expected 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare_exchange_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。

与compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允许(spuriously 地)返回 false，即原子对象所封装的值与参数 expected 的物理内容相同，比较操作一定会为 true。不过在某些平台下，如果算法本身需要循环操作来做检查， compare_exchange_weak 的性能会更好。

因此对于某些不需要采用循环操作的算法而言, 通常采用compare_exchange_strong 更好。另外，该函数的内存序由 sync 参数指定，可选条件如下：
在这里插入图片描述
请看下面的例子：

#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector
 
// a simple global linked list:
struct Node { 
    int value; 
    Node* next; 
};
std::atomic<Node*> list_head(nullptr);
 
void append(int val)
{
    // append an element to the list
    Node* newNode = new Node{val, list_head};
 
    // next is the same as: list_head = newNode, but in a thread-safe way:
 
    while (!(list_head.compare_exchange_strong(newNode->next, newNode)));
    // (with newNode->next updated accordingly if some other thread just appended another node)
}
 
int main ()
{
    // spawn 10 threads to fill the linked list:
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) 
        threads.push_back(std::thread(append, i));

    for (auto& th : threads) 
        th.join();
 
    // print contents:
    for (Node* it = list_head; it!=nullptr; it=it->next)
        std::cout << ' ' << it->value;
 
    std::cout << '\n';
 
    // cleanup:
    Node* it; 
    while (it=list_head) {
        list_head=it->next; 
        delete it;
    }
 
    return 0;
}
碎步の流年
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++并发编程实战:示例源源码
06-14
《C++并发编程实战》是一本深入探讨C++并发编程技术的书籍，其源码库名为Cpp-Concurrency-in-Action-master。并发编程是现代多核处理器环境下提高软件性能的关键技术，C++作为一门强大且灵活的编程语言，提供了丰富...
std::atomic
友善啊，朋友的博客
01-20 2703
不仅支持数值类型，还支持其他可赋值类型。int age;t1.join();t2.join();return 0;
C++11之原子操作原理与使用(一百二十)
Android系统攻城狮
06-07 4588
【1】单个CPU的情况【1】有两个线程，线程thread1对变量aa读操作，线程thread2对变量中写值。 【2】在线程thread1里，对aa读操作，放入tmp变量中，以后使用 【3】在线程thread2里，对aa写操作 结果：原本是想读出来aa = 5的值，结果可能读出来是已经修改的值100，不是自己想要的脏数据，所以对变量读写要保持其原子性----->即：执行中不可被打断。原子操作： 可以把原子操作理解为：不需要用到互斥量加锁（无锁）技术的多线程编程方式，多线程中不会被打断的程序执行片段
C++(26): 原子操作（std::atomic）
最新发布
tecsai的博客
06-21 1154
开发过多线程、并发编程的小伙伴一定接触过mutex，通过对资源进行加锁和解锁，实现对方问和修改的互斥操作。mutex使用起来很方便，很强大，但也有局限性。频繁地加锁和解锁会造成较大的资源消耗，影像系统的性能。 与mutex相比，原子（atomic）操作相对灵活和简单。 注意，这种灵活性在一定程度上是做了某些妥协的。
C++并发编程 | 原子操作std::atomic
热门推荐
weixin_44479862的博客
11-27 1万+
C++并发编程 | 原子操作std::atomic
第十一节std::atomic原子操作
HITXJ的博客
09-16 9797
一、原子操作 1.1原子操作概念例子 互斥量：多线程编程中保护共享数据：锁，操作共享数据，开锁 有两个线程，对一个变量进行操作，这个线程读，另一个线程往变量中写值。 int atomvalue = 5; 读线程A： int tmpvalue = atomvalue;//atomvalue代表的是多个线程之间要共享的变量 写线程B： atomvalue = 6; 结果：读出一个不可预料的中间值 原子操作： 可以把原子操作理解为一种：不需要用到互斥量加锁（无锁）技术的多线程编程方式 多线程中不会被打断的程
C++ 多线程：std::atomic模板特化
这是一个c++热爱者的博客哟
01-24 4167
自增运算符重载，有两种形式，第一种形式 (1) 返回自增后的值（即前缀++），第二种形式(2) 返回自增前的值（即后缀++），适用于整形和指针类型的 std::atomic 特化版本。自减运算符重载，有两种形式， 第一种形式 (1) 返回自减后的值（即前缀–），第二种形式(2) 返回自减前的值（即后缀–），适用于整形和指针类型的 std::atomic 特化版本。将原子对象的封装值减 val，并返回原子对象的旧值，适用于整形和指针类型的 std::atomic 特化版本，整个过程是原子的。
C++11中原子变量std::atomic使用小记
hsy12342611的专栏
11-09 4682
C++11 std::atomic
C++ 中的原子变量（std::atomic）使用指南
qq_46017342的博客
09-12 1万+
C++ 中的原子变量（std::atomic）使用指南
C++11 并发指南之多线程初探
12-20
C++11是C++语言的一个重要里程碑，它引入了许多新特性，特别是在并发编程领域，大大提升了C++作为多线程编程语言的能力。本篇文章将深入探讨C++11中的多线程支持。 在C++11之前，开发人员通常依赖于如POSIX的...
线程安全的std :: map和无锁映射的速度
04-11
2. **无锁编程**：无锁编程（Lock-free Programming）是一种优化多线程并发性能的技术，它避免了线程间的互斥锁定，通过原子操作（如std::atomic）来更新数据，从而减少锁竞争，提高系统效率。无锁映射（Lock-free ...
我们使std :: shared_mutex快10倍
04-11
标题中的“我们使std::shared_mutex快10倍”揭示了一个关于C++多线程并发编程的优化案例，其中std::shared_mutex是C++11引入的一种互斥锁，用于支持读写锁，允许多个读取者同时访问共享资源而只允许一个写入者。...
c++ 11 原子操作库 （std::atomic）（一）
qq_40788199的博客
09-19 2247
每个 std::atomic 模板的实例化和全特化定义一个原子类型。若一个线程写入原子对象，同时另一线程从它读取，则行为良好定义（数据竞争的细节见内存模型）。
12C++11多线程编程之原子操作std::atomic
weixin_44517656的博客
01-03 2647
1 原子操作std::atomic相关概念 前言： 原子操作：更小的代码片段，并且该片段必定是连续执行的，不可分割。 1.1 原子操作std::atomic与互斥量的区别 1）互斥量：类模板，保护一段共享代码段，可以是一段代码，也可以是一个变量。 2）原子操作std::atomic：类模板，保护一个变量。 1.2 为何需要原子操作std::atomic 上面可以看到，为何已经有互斥量了，还要引入std::atomic呢，这是因为互斥量保护的数据范围比较大，我们期望更小范围的保护。并且当共享数据为一个
C++并发实战16: std::atomic原子操作
Poo_Chai的博客
06-25 5766
文章出处：https://blog.csdn.net/liuxuejiang158blog/article/details/17413149 C++中对共享数据的存取在并发条件下可能会引起data race的undifined行为，需要限制并发程序以某种特定的顺序执行，有两种方式：使用mutex保护共享数据，原子操作：针对原子类型操作要不一步完成，要么不做，不可能出现操作一半被切换CPU，...
C++并发编程（五）内存模型与原子操作
CSSS_2021的博客
02-02 2515
《C++并发编程实战》笔记
std::atomic 相关接口(来自cppreference.com)
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-17 1038
https://en.cppreference.com/w/cpp/atomic/atomic
c++原子操作 std::atomic
xie__jin__cheng的博客
05-10 592
c++原则操作 std::atomic
C++11新特性之十五：std::atomic
草上爬的博客
06-19 3946
在以往的C++标准中并没有对原子操作进行规定，在新标准C++11，引入了原子操作的概念，并通过头文件#include 提供了多种原子操作数据类型，这些类型上的所有操作都是原子的。如果我们在多个线程中对这些类型的共享资源进行操作，编译器将保证这些操作都是原子性的，也就是说，确保任意时刻只有一个线程对这个资源进行访问，编译器将保证，多个线程访问这个共享资源的正确性。从而避免了锁的使用，提高了效率。
c++14 std::atomic_bool
09-09
std::atomic_bool是C++14中的原子布尔类型。它提供了原子操作，以确保多线程环境下的安全性。它可以用于实现锁、同步和并发算法等。使用std::atomic_bool可以保证对布尔类型的读写操作在多线程环境中是原子的，即不会发生竞态条件。 在C++14中，std::atomic_bool比std::atomic_flag功能更全，可以使用非原子的bool来赋值和初始化。例如，你可以这样使用std::atomic_bool： std::atomic_bool b(true); b = false; 这样就可以对b进行原子的赋值操作。 需要注意的是，std::atomic_flag由于限制性甚至不能用作一个通用的布尔标识，所以最好还是使用std::atomic_bool。在C语言中，也可以使用自旋锁来实现多线程的同步。以下是一个使用自旋锁实现的例子： #include <thread> #include <vector> #include <iostream> #include <atomic> std::atomic_flag lock = ATOMIC_FLAG_INIT; void f(int n) { for (int cnt = 0; cnt < 5; cnt++) { while (lock.test_and_set(std::memory_order_acquire)) ; // 自旋 std::cout << "Thread " << n << " count:" << cnt << std::endl; lock.clear(std::memory_order_release); // 释放锁 } } int main(int argc, char* argv[]) { std::vector<std::thread> v; for (int n = 0; n < 4; n++) { v.emplace_back(f, n); //使用参数进行初始化 } for (auto& t : v) { t.join(); //等待线程结束 } system("pause"); return 0; } 这个例子中，使用std::atomic_flag作为锁，通过test_and_set()和clear()函数来获得锁和释放锁。 总结来说，std::atomic_bool是C++14中的原子布尔类型，可以用于多线程环境下的安全操作。在C语言中，可以使用自旋锁来实现多线程的同步。<span class="em">1</span><span class="em">2</span><span class="em">3</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值