Namespaces
Variants

std:: atomic_fetch_sub, std:: atomic_fetch_sub_explicit

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
atomic_fetch_sub atomic_fetch_sub_explicit
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
Definiert im Header <atomic>
template < class T >

T atomic_fetch_sub ( std:: atomic < T > * obj,

typename std:: atomic < T > :: difference_type arg ) noexcept ;
(1) (seit C++11)
template < class T >

T atomic_fetch_sub ( volatile std:: atomic < T > * obj,

typename std:: atomic < T > :: difference_type arg ) noexcept ;
(2) (seit C++11)
template < class T >

T atomic_fetch_sub_explicit ( std:: atomic < T > * obj,
typename std:: atomic < T > :: difference_type arg,

std:: memory_order order ) noexcept ;
(3) (seit C++11)
template < class T >

T atomic_fetch_sub_explicit ( volatile std:: atomic < T > * obj,
typename std:: atomic < T > :: difference_type arg,

std:: memory_order order ) noexcept ;
(4) (seit C++11)

Führt eine atomare Subtraktion durch. Subtrahiert atomar arg von dem Wert, auf den obj zeigt, und gibt den Wert zurück, der zuvor in obj gespeichert war. Die Operation wird so ausgeführt, als ob Folgendes ausgeführt würde:

1,2) obj - > fetch_sub ( arg )
3,4) obj - > fetch_sub ( arg, order )

Wenn std::atomic<T> kein fetch_sub Mitglied hat (dieses Mitglied wird nur für integrale , Gleitkomma- (seit C++20) und Zeiger Typen außer bool bereitgestellt), ist das Programm fehlerhaft.

Inhaltsverzeichnis

Parameter

obj - Zeiger auf das atomare Objekt, das modifiziert werden soll
arg - der Wert, der vom im atomaren Objekt gespeicherten Wert subtrahiert werden soll
order - die Speichersynchronisierungsreihenfolge

Rückgabewert

Der Wert unmittelbar vor den Auswirkungen dieser Funktion in der modification order von * obj .

Beispiel

Mehrere Threads können std::atomic_fetch_sub verwenden, um gleichzeitig einen indizierten Container zu verarbeiten.

Diesen Code ausführen 
#include <atomic>
#include <iostream>
#include <numeric>
#include <string>
#include <thread>
#include <vector>
const int N = 50;
std::atomic<int> cnt;
std::vector<int> data(N);
void reader(int id) 
{
    for (;;)
    {
        int idx = atomic_fetch_sub_explicit(&cnt, 1, std::memory_order_relaxed);
        if (idx >= 0)
            std::cout << "reader " << std::to_string(id) << " processed item "
                      << std::to_string(data[idx]) << '\n';
        else
        {
            std::cout << "reader " << std::to_string(id) << " done\n";
            break;
        }
    }
}
int main()
{
    std::iota(data.begin(), data.end(), 1);
    cnt = data.size() - 1;
    std::vector<std::thread> v;
    for (int n = 0; n < 5; ++n)
        v.emplace_back(reader, n);
    for (auto& t : v)
        t.join();
}

Ausgabe: 

reader 2 processed item 50
reader 1 processed item 44
reader 4 processed item 46
<....>
reader 0 done
reader 4 done
reader 3 done

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
P0558R1 C++11 exakte Typübereinstimmung war erforderlich, weil
T von mehreren Argumenten abgeleitet wurde 		T wird nur von
obj abgeleitet

Siehe auch

subtrahiert atomar das Argument vom im atomaren Objekt gespeicherten Wert und erhält den zuvor gehaltenen Wert
(öffentliche Mitgliedsfunktion von std::atomic<T> )
(C++11) (C++11)
addiert einen nicht-atomaren Wert zu einem atomaren Objekt und erhält den vorherigen Wert des atomaren Objekts
(Funktions-Template)
C-Dokumentation für atomic_fetch_sub , atomic_fetch_sub_explicit