std::atomic_fetch_and, std::atomic_fetch_and_explicit
De cppreference.com
| Definido en el archivo de encabezado <atomic>
|
||
template< class T >
T atomic_fetch_and( std::atomic<T>* obj,
typename std::atomic<T>::value_type arg ) noexcept;
|
||
template< class T >
T atomic_fetch_and( volatile std::atomic<T>* obj,
typename std::atomic<T>::value_type arg ) noexcept;
|
||
template< class T >
T atomic_fetch_and_explicit( std::atomic<T>* obj,
typename std::atomic<T>::value_type arg,
std::memory_order order) noexcept;
|
||
template< class T >
T atomic_fetch_and_explicit( volatile std::atomic<T>* obj,
typename std::atomic<T>::value_type arg,
std::memory_order order) noexcept;
|
||
Reemplaza atómicamente el valor al que apunta obj con el resultado de una operación AND bit a bit entre el valor antiguo de obj y arg. Devuelve el valor que obj tenía anteriormente.
La operación se realiza como si se hubiera ejecutado lo siguiente:
1)
obj->fetch_and(arg)2)
obj->fetch_and(arg, order)Si std::atomic<T> no tiene un miembro fetch_and (este miembro solo se proporciona para tipos enteros), el programa está mal formado.
Parámetros
| obj | - | Un puntero al objeto atómico a modificar. bool no es un tipo entero a los efectos de las operaciones atómicas.
|
| arg | - | El valor al cual aplicar la operación AND bit a bit y al valor almacenado en el objeto atómico. |
| order | - | El ordenamiento de sincronización de memoria para esta operación. Se permiten todos los valores. |
Valor de retorno
El valor inmediatamente anterior a los efectos de esta función en el orden de modificación de *obj.
Posible implementación
template< class T >
T atomic_fetch_and(std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept
{
return obj->fetch_and(arg);
}
|
Ejemplo
Ejecuta este código
#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
#include <functional>
// Semáforo binario solo a efectos de demostración
// Es un ejemplo sencillo pero significativo: las operaciones atómicas
// son innecesarias sin hilos.
class Semaphore {
std::atomic_char m_signaled;
public:
Semaphore(bool initial = false)
{
m_signaled = initial;
}
// Se bloquea hasta que el semáforo se señale
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(); // señal de impresión a ocurrir
m_count_sem.take(); // esperar hasta que la impresión complete
}
}
std::cout << "count_up() lista\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() lista\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();
}
Salida:
10
20
30
40
50
60
70
80
90
100
print_count() lista
count_up() lista
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| P0558R1 | C++11 | Se requiere una coincidencia de tipo exacta porque Tse deduce de varios argumentos. |
T se deduce únicamente del argumento atomic.
|
Véase también
(C++11) |
realiza atómicamente AND bit a bit entre el argumento y el valor del objeto atómico y obtiene el valor que tenía antes Original: atomically performs bitwise AND between the argument and the value of the atomic object and obtains the value held previously The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (función miembro pública de std::atomic)
|
(C++11)(C++11) |
Reemplaza el objeto atómico con el resultado de la operación lógica OR con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) |
Reemplaza el objeto atómico con el resultado de la operación lógica XOR con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
Documentación de C para atomic_fetch_and, atomic_fetch_and_explicit
| |