Namensräume
Varianten
Aktionen

std::atomic_fetch_sub, std::atomic_fetch_sub_explicit

Von cppreference.com
< cpp‎ | atomic
 
C++
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
(C++17)(C++17)
this_thread Namespace
(C++11)
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
(C++11)
(C++17)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
Bedingungsvariablen
(C++11)
(C++11)
(C++11)
(C++11)
Semaphoren
(C++20)(C++20)
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
(C++26)
(C++26)
Hazard Pointer
(C++26)
(C++26)
(C++26)
Atomare Typen
(C++11)
(C++20)
(C++11)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
(C++11)
Speicherordnung
(C++11)
(C++11)(deprecated in C++26)
(C++11)
(C++11)
Freie Funktionen für atomare Operationen
(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_subatomic_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)
Freie Funktionen für atomare Flags
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
Definiert in 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 arg atomar von dem Wert, auf den obj zeigt, und gibt den zuvor von obj gehaltenen Wert zurück. Die Operation wird so ausgeführt, als ob Folgendes ausgeführt worden wäre:

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 Ganzzahltypen, Gleitkommatypen(seit C++20) und Zeigertypen außer bool bereitgestellt), ist das Programm ill-formed.

Inhalt

[bearbeiten] Parameter

obj - Zeiger auf das zu modifizierende atomare Objekt
arg - der Wert, der vom Wert im atomaren Objekt subtrahiert werden soll
Reihenfolge - die Speicher-Synchronisationsreihenfolge

[bearbeiten] Rückgabewert

Der Wert, der den Effekten dieser Funktion in der Modifikationsreihenfolge von *obj unmittelbar vorausging.

[bearbeiten] Beispiel

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

Führen Sie diesen Code aus
#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

[bearbeiten] 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 exakter Typabgleich war erforderlich, weil
T aus mehreren Argumenten abgeleitet wurde		 T wird nur abgeleitet
von obj

[bearbeiten] Siehe auch

 subtrahiert atomar das Argument vom Wert, der im atomaren Objekt gespeichert ist, und erhält den zuvor gehaltenen Wert
(öffentliche Memberfunktion von std::atomic<T>) [bearbeiten]
(C++11)(C++11)
 addiert einen nicht-atomaren Wert zu einem atomaren Objekt und gibt den vorherigen Wert des atomaren Objekts zurück
(Funktions-Template) [bearbeiten]
C-Dokumentation für atomic_fetch_sub, atomic_fetch_sub_explicit
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/atomic/atomic_fetch_sub&oldid=161341"