Làm thế nào để phủ nhận nguyên tử một std :: atomic_bool?

Question

Các ngây thơ boolean phủ

std::atomic_bool b; 
b = !b; 

dường như không phải là nguyên tử. Tôi nghi ngờ điều này là bởi vì operator! kích hoạt một diễn viên để đồng bằng bool. Làm thế nào để thực hiện một cách nguyên tử sự phủ định tương đương? Các mã sau minh họa rằng sự phủ định ngây thơ không phải là nguyên tử:

#include <thread> 
#include <vector> 
#include <atomic> 
#include <iostream> 

typedef std::atomic_bool Bool; 

void flipAHundredThousandTimes(Bool& foo) { 
    for (size_t i = 0; i < 100000; ++i) { 
    foo = !foo; 
    } 
} 

// Launch nThreads std::threads. Each thread calls flipAHundredThousandTimes 
// on the same boolean 
void launchThreads(Bool& foo, size_t nThreads) { 

    std::vector<std::thread> threads; 
    for (size_t i = 0; i < nThreads; ++i) { 
    threads.emplace_back(flipAHundredThousandTimes, std::ref(foo)); 
    } 

    for (auto& thread : threads) thread.join(); 

} 

int main() { 

    std::cout << std::boolalpha; 
    Bool foo{true}; 

    // launch and join 10 threads, 20 times. 
    for (int i = 0; i < 20; ++i) { 
    launchThreads(foo, 10); 
    std::cout << "Result (should be true): " << foo << "\n"; 
    } 

} 

Mã này ra mắt 10 chủ đề, mỗi trong số đó flips các atomic_bool một larrge, thậm chí, số lần (100000), và in ra boolean. Điều này được lặp lại 20 lần.

EDIT: Đối với những người muốn chạy mã này, tôi đang sử dụng ảnh chụp GCC 4.7 trên ubuntu 11.10 với hai lõi. Các tùy chọn biên dịch là:

-std=c++0x -Wall -pedantic-errors -pthread 

Answer 1

b = !b không phải là nguyên tử bởi vì nó bao gồm cả đọc và ghi, mỗi trong số đó là một hoạt động nguyên tử.

Có hai tùy chọn để sử dụng:

1. Thay vì atomic<bool>, sử dụng một loại không thể thiếu (ví dụ atomic<int>) mà có thể là 0 hoặc 1, và xor nó với 1:

   std::atomic<int> flag(0); 
   
   flag ^= 1; //or flag.fetch_xor(1); 
   

   Thật không may, fetch_xor không được cung cấp trên atomic<bool>, chỉ trên các loại tích phân.

2. Thực hiện một so sánh/hoạt động trao đổi trong vòng một, cho đến khi nó thành công:

   std::atomic<bool> flag(false); 
   
   bool oldValue = flag.load(); 
   while (!flag.compare_exchange_weak(oldValue, !oldValue)) {}