#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* oldHead = list_head; Node* newNode = new Node {val,oldHead}; // what follows is equivalent to: list_head = newNode, but in a thread-safe way: while (!list_head.compare_exchange_weak(oldHead,newNode)) { newNode->next = oldHead; } } int main () { // spawn 10 threads to fill the linked list: std::vector<std::thread> threads; for (int i=0; i<30; ++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 << ' '; // cleanup: Node* it; while (it=list_head) {list_head=it->next; delete it;} return 0; }
#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* oldHead = list_head; Node* newNode = new Node {val,oldHead}; // what follows is equivalent to: list_head = newNode, but in a thread-safe way: while (!list_head.compare_exchange_weak(oldHead,newNode)) { newNode->next = oldHead; } } int main () { // spawn 10 threads to fill the linked list: std::vector<std::thread> threads; for (int i=0; i<30; ++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 << ' '; // cleanup: Node* it; while (it=list_head) {list_head=it->next; delete it;} return 0; }
root@ubuntu:~/c++# g++ -std=c++11 weak.cpp -o weak -pthread root@ubuntu:~/c++# ./weak 29 28 27 23 26 25 24 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 root@ubuntu:~/c++#
在看c++11的CAS用法的时候，主要是产生了两个问题：
- compare_swap_strong 与 compare_swap_weak 有啥区别?
- c++11 CAS原语系列后面还有两个
memory_order参数，有什么作用？
/* * @brief：compare & swap(CAS)。如果等于expect则swap，否则就返回--是否交换成功, 注意expect如果不相等，会把当前值写入到expected里面。 * 相比于strong，weak可能会出现[spurious wakeup](<http://en.wikipedia.org/wiki/Spurious_wakeup>). * @param 若x等于expect,则设置为desired 返回true， * 否则最新值写入expect，返回false */ class atomic { bool compare_exchange_strong(T& expect /*用来比较的值*/, T desired/*用来设置的值*/) bool compare_exchange_weak(T& expect, T desired) }
compare_swap_strong 与 compare_swap_weak
看一下compare_swap_strong()的实现是如何的？
首先介绍一下几个定义好的与操作，实际上就是几个enum
// 几个与操作是经过了重载的。 /// Enumeration for memory_order typedef enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst } memory_order; enum __memory_order_modifier { __memory_order_mask = 0x0ffff, __memory_order_modifier_mask = 0xffff0000, __memory_order_hle_acquire = 0x10000, __memory_order_hle_release = 0x20000 }; // & operator constexpr memory_order operator&(memory_order __m, __memory_order_modifier __mod) { return memory_order(__m & int(__mod)); }
可以简单地理解为几个常量在操作。接下来看真正的实现部分。
/c++/atomic 头文件 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } // atomic_base _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; __glibcxx_assert(__b2 != memory_order_release); __glibcxx_assert(__b2 != memory_order_acq_rel); __glibcxx_assert(__b2 <= __b1); return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); }
最后发现__atomic_compare_exchange_n是由GCC内置的函数。
gcc 内置
Built-in Function:
bool __atomic_compare_exchange_n( type *ptr, // 需要进行比较的ptr type *expected, // 旧的值，会返回ptr里面的值 type desired, // 想要设置的新的值 bool weak, // 强一致，还是弱一致 int success_memorder, // 成功时的内存序 int failure_memorder // 失败时的内存序 )
weak与strong
参考文档gcc内置CAS说明
详细的说明如下,如果有耐心那么可以直接看完。如果没有耐心，可以直接看一下我自己的结论。
- weak = true的时候，对应c++11的
compare_exchange_weak函数。 - weak = false的时候，对应的是
compare_exchange_strong函数。
区别这两个函数的区别在于，weak在有的平台上（注意，是有的平台，这里不包括x86）会存在失败的可能性。即，当*ptr == *expected依然有可能什么都不做而返回false。
所以，在x86平台来说，这两者可以说是没什么区别。只是如果想要代码可移值性好，那么采用compare_exchange_weak并且使用循环来判断，那么是一种比较好的办法。
结论就是:
- 想要性能，使用
compare_exchange_weak+循环来处理。 - 想要简单，使用
compare_exchange_strong。 - 如果是x86平台，两者没区别
- 如果想在移值的时候，拿到高性能，用
compare_exchange_weak。
详细的说明
需要注意的是，weak = true表示弱CAS，在这种情况下，就是交换成功，也有可能返回失败。
在某些平台上，即使 atomic的值和expected一樣，weak 版仍有可能会失败。但是绝大多数情況不会失敗，且 weak 版的运行比strong版快。所以若本来就需要在循环里执行 compare-and-swap，用 weak 版较有效率；反之，只执行一次的話，用 strong 版可以省去不必要的循环。
所以weak和strong的区别在于，weak仍然在*ptr == expected的时候，执行依然会有小概率失败。也就是说， 即使*ptr == expected，此时也不会发生值的设置，也会返回false。（不会是设置成功了，但是返回的是false）。
Many targets only offer the strong variation and ignore the parameter. When in doubt, use the strong variation.
一般而言，当你拿不准，就使用strong的版本。
If desired is written into *ptr then true is returned and memory is affected according to the memory order specified by success_memorder. There are no restrictions on what memory order can be used here.
Otherwise, false is returned and memory is affected according to failure_memorder. This memory order cannot be ATOMIC_RELEASE nor ATOMIC_ACQ_REL. It also cannot be a stronger order than that specified by success_memorder.
如果需要写入* ptr则返回true，并根据success_memorder指定的内存顺序影响内存。 这里可以使用什么内存顺序没有限制。
否则，返回false并根据failure_memorder影响内存。 此内存顺序不能是ATOMIC_RELEASE和ATOMIC_ACQ_REL 。 它也不可能比success_memorder指定的顺序更强大。
两个内存序
这个函数系列有趣的是，后面还有两个有趣的memory_order序。那么这两个memory_order起什么作用呢？
结论就是，针对x86平台来说，取什么值都是一样的。可以拿一段简单的代码进行尝试，注意查看生成的汇编代码。
#include <pthread.h> #include <stdbool.h> extern int a_lock; int a_lock = 0; static bool lock(int *l) { int tmp = 0; return __atomic_compare_exchange_n(l, &tmp, 1, true , __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } static void unlock(int *l) { __atomic_store_n(l, 0, __ATOMIC_SEQ_CST); } int main(int argc, char *argv[]) { lock(&a_lock); unlock(&a_lock); }
root@ubuntu:~/c++# g++ -S -O0 -std=c++11 weak.cpp -o weak -pthread root@ubuntu:~/c++# cat weak .arch armv8-a .file "weak.cpp" .global a_lock .bss .align 2 .type a_lock, %object .size a_lock, 4 a_lock: .zero 4 .text .align 2 .type _ZL4lockPi, %function _ZL4lockPi: .LFB14: .cfi_startproc stp x29, x30, [sp, -48]! .cfi_def_cfa_offset 48 .cfi_offset 29, -48 .cfi_offset 30, -40 add x29, sp, 0 .cfi_def_cfa_register 29 str x0, [x29, 24] adrp x0, :got:__stack_chk_guard ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 40] mov x1,0 str wzr, [x29, 36] ldr x1, [x29, 24] add x0, x29, 36 ldr w3, [x0] mov w4, 1 ldaxr w2, [x1] cmp w2, w3 bne .L5 stlxr w5, w4, [x1] cmp w5, 0 .L5: cset w1, eq cmp w1, 0 bne .L2 str w2, [x0] .L2: mov w0, w1 adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 40] ldr x1, [x1] eor x1, x2, x1 cmp x1, 0 beq .L4 bl __stack_chk_fail .L4: ldp x29, x30, [sp], 48 .cfi_restore 30 .cfi_restore 29 .cfi_def_cfa 31, 0 ret .cfi_endproc .LFE14: .size _ZL4lockPi, .-_ZL4lockPi .align 2 .type _ZL6unlockPi, %function _ZL6unlockPi: .LFB15: .cfi_startproc sub sp, sp, #16 .cfi_def_cfa_offset 16 str x0, [sp, 8] ldr x0, [sp, 8] stlr wzr, [x0] nop add sp, sp, 16 .cfi_def_cfa_offset 0 ret .cfi_endproc .LFE15: .size _ZL6unlockPi, .-_ZL6unlockPi .align 2 .global main .type main, %function main: .LFB16: .cfi_startproc stp x29, x30, [sp, -32]! .cfi_def_cfa_offset 32 .cfi_offset 29, -32 .cfi_offset 30, -24 add x29, sp, 0 .cfi_def_cfa_register 29 str w0, [x29, 28] str x1, [x29, 16] adrp x0, a_lock add x0, x0, :lo12:a_lock bl _ZL4lockPi adrp x0, a_lock add x0, x0, :lo12:a_lock bl _ZL6unlockPi mov w0, 0 ldp x29, x30, [sp], 32 .cfi_restore 30 .cfi_restore 29 .cfi_def_cfa 31, 0 ret .cfi_endproc .LFE16: .size main, .-main .ident "GCC: (Ubuntu/Linaro 5.5.0-12ubuntu1) 5.5.0 20171010" .section .note.GNU-stack,"",@progbits root@ubuntu:~/c++#
root@ubuntu:~/c++# cat weak .arch armv8-a .file "weak.cpp" .section .text.startup,"ax",@progbits .align 2 .p2align 3,,7 .global main .type main, %function main: .LFB17: .cfi_startproc adrp x0, :got:__stack_chk_guard stp x29, x30, [sp, -32]! .cfi_def_cfa_offset 32 .cfi_offset 29, -32 .cfi_offset 30, -24 adrp x1, .LANCHOR0 add x29, sp, 0 .cfi_def_cfa_register 29 ldr x4, [x0, #:got_lo12:__stack_chk_guard] add x2, x1, :lo12:.LANCHOR0 ldr x5, [x4] str x5, [x29, 24] mov x5,0 str wzr, [x29, 20] ldaxr w4, [x2] cmp w4, 0 bne .L4 mov w3, 1 stlxr w5, w3, [x2] cmp w5, 0 .L4: beq .L2 str w4, [x29, 20] .L2: add x1, x1, :lo12:.LANCHOR0 stlr wzr, [x1] ldr x1, [x0, #:got_lo12:__stack_chk_guard] mov w0, 0 ldr x2, [x29, 24] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L7 ldp x29, x30, [sp], 32 .cfi_remember_state .cfi_restore 30 .cfi_restore 29 .cfi_def_cfa 31, 0 ret .L7: .cfi_restore_state bl __stack_chk_fail .cfi_endproc .LFE17: .size main, .-main .global a_lock .bss .align 2 .LANCHOR0 = . + 0 .type a_lock, %object .size a_lock, 4 a_lock: .zero 4 .ident "GCC: (Ubuntu/Linaro 5.5.0-12ubuntu1) 5.5.0 20171010" .section .note.GNU-stack,"",@progbits root@ubuntu:~/c++#
可以尝试去修改一下__atomic_compare_exchange_n后面两个内存序。可以发现最后生成的汇编代码没有什么区别。
小结
- 为了跨平台性以及高性能，那么使用
compare_exchange_weak好的办法。 - 后面的两个内存序，使用默认的
std::memory_order_seq_cst即可。这是因为，在x86平台上，微调这两个参数生成的代码都是一样的，没有什么收益。其他弱内存序的cpu上面，可能每种cpu得到的最合适的这两个参数都会有所不同。为了避免去适配各个cpu，那么一种偷懒的办法就是直接使用std::memory_order_seq_cst。
一句话就是，直接使用var.compare_exchange_weak(a,b);这种形式最省事。比如：
void link_nodes_atomic(node * new_top_node, node * end_node) { tagged_node_handle old_tos = tos.load(detail::memory_order_relaxed); for (;;) { tagged_node_handle new_tos (pool.get_handle(new_top_node), old_tos.get_tag()); end_node->next = pool.get_handle(old_tos); if (tos.compare_exchange_weak(old_tos, new_tos)) break; } }
#include <atomic> template<class T> struct node { T data; node* next; node(const T& data) : data(data), next(nullptr) {} }; template<class T> class stack { std::atomic<node<T>*> head; public: void push(const T& data) { node<T>* new_node = new node<T>(data); new_node->next = head.load(std::memory_order_relaxed); while(!std::atomic_compare_exchange_weak_explicit(&head, &new_node->next, new_node, std::memory_order_release, std::memory_order_relaxed)) ; } }; int main() { stack<int> s; s.push(1); s.push(2); s.push(3); }