Libreria atomica C ++ - Recupera e
Descrizione
Sostituisce l'oggetto atomico con il risultato di AND logico con un argomento non atomico e ottiene il valore precedente dell'atomico.
Dichiarazione
Di seguito è riportata la dichiarazione per std :: atomic_fetch_and.
template< class Integral >
Integral atomic_fetch_and( volatile std::atomic>Integral>* obj, Integral arg );
C ++ 11
template< class Integral >
Integral atomic_fetch_and( std::atomic<Integral>* obj, Integral arg );
La seguente è la dichiarazione per std :: atomic_fetch_and_explicit.
template< class Integral >
Integral atomic_fetch_and_explicit( std::atomic<Integral>* obj,
Integral arg,
std::memory_order order);
C ++ 11
template< class Integral >
Integral atomic_fetch_and_explicit( volatile std::atomic<Integral>* obj,
Integral arg,
std::memory_order order);
Parametri
obj - Viene utilizzato nel puntatore all'oggetto atomico da modificare.
desr - Viene utilizzato per memorizzare il valore nell'oggetto atomico.
order - Viene utilizzato per sincronizzare l'ordine della memoria per questa operazione.
Valore di ritorno
Restituisce il valore immediatamente precedente agli effetti di questa funzione nell'ordine di modifica di * obj.
Eccezioni
No-noexcept - questa funzione membro non genera mai eccezioni.
Esempio
Nell'esempio seguente per std :: atomic_fetch_and_explicit.
#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
#include <functional>
class Semaphore {
std::atomic_char m_signaled;
public:
Semaphore(bool initial = false) {
m_signaled = initial;
}
void take() {
while (!std::atomic_fetch_and(&m_signaled, false)) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
void put() {
std::atomic_fetch_or(&m_signaled, true);
}
};
class ThreadedCounter {
static const int N = 100;
static const int REPORT_INTERVAL = 10;
int m_count;
bool m_done;
Semaphore m_count_sem;
Semaphore m_print_sem;
void count_up() {
for (m_count = 1; m_count <= N; m_count++) {
if (m_count % REPORT_INTERVAL == 0) {
if (m_count == N) m_done = true;
m_print_sem.put();
m_count_sem.take();
}
}
std::cout << "count_up() done\n";
m_done = true;
m_print_sem.put();
}
void print_count() {
do {
m_print_sem.take();
std::cout << m_count << '\n';
m_count_sem.put();
} while (!m_done);
std::cout << "print_count() done\n";
}
public:
ThreadedCounter() : m_done(false) {}
void run() {
auto print_thread = std::thread(&ThreadedCounter::print_count, this);
auto count_thread = std::thread(&ThreadedCounter::count_up, this);
print_thread.join();
count_thread.join();
}
};
int main() {
ThreadedCounter m_counter;
m_counter.run();
}