std::jthread:: jthread
|
jthread
(
)
noexcept
;
|
(1) | (seit C++20) |
|
jthread
(
jthread
&&
other
)
noexcept
;
|
(2) | (seit C++20) |
|
template
<
class
F,
class
...
Args
>
explicit jthread ( F && f, Args && ... args ) ; |
(3) | (seit C++20) |
|
jthread
(
const
jthread
&
)
=
delete
;
|
(4) | (seit C++20) |
Konstruiert ein neues
std::jthread
Objekt.
std::jthread
Objekt, das keinen Thread repräsentiert.
std::jthread
Objekt, um den Ausführungs-Thread darzustellen, der zuvor durch
other
repräsentiert wurde. Nach diesem Aufruf stellt
other
keinen Ausführungs-Thread mehr dar.
std::jthread
-Objekt und verknüpft es mit einem Ausführungs-Thread.
Der neue Ausführungs-Thread beginnt mit der Ausführung von:
std::
invoke
(
decay-copy
(
std::
forward
<
F
>
(
f
)
)
, get_stop_token
(
)
,
decay-copy
(
std::
forward
<
Args
>
(
args
)
)
...
)
|
(bis C++23) |
|
std::
invoke
(
auto
(
std::
forward
<
F
>
(
f
)
)
, get_stop_token
(
)
,
|
(seit C++23) |
falls der obige Ausdruck wohlgeformt ist, andernfalls beginnt die Ausführung von:
std::
invoke
(
decay-copy
(
std::
forward
<
F
>
(
f
)
)
,
decay-copy
(
std::
forward
<
Args
>
(
args
)
)
...
)
.
|
(bis C++23) |
|
std::
invoke
(
auto
(
std::
forward
<
F
>
(
f
)
)
,
|
(seit C++23) |
std::jthread
ist.
- std:: is_constructible_v < std:: decay_t < F > , F >
- ( std:: is_constructible_v < std:: decay_t < Args > , Args > && ... )
-
std::
is_invocable_v
<
std::
decay_t
<
F
>
,
std::
decay_t
<
Args
>
...
>
||
std:: is_invocable_v < std:: decay_t < F > , std:: stop_token , std:: decay_t < Args > ... >
std::jthread
-Objekte dürfen denselben Ausführungs-Thread repräsentieren.
Inhaltsverzeichnis |
Parameter
| other | - |
ein weiteres
std::jthread
Objekt, mit dem dieses
std::jthread
Objekt konstruiert werden soll
|
| f | - | Callable Objekt, das im neuen Thread ausgeführt werden soll |
| args | - | Argumente, die an die neue Funktion übergeben werden sollen |
Nachbedingungen
get_id()
entspricht
std::jthread::id()
(d.h.
joinable()
gibt
false
zurück) und
get_stop_source
(
)
.
stop_possible
(
)
ist
false
.
get_id()
gibt den Wert von
other.
get_id
(
)
vor Beginn der Konstruktion zurück.
get_id()
ungleich
std::jthread::id()
(d.h.
joinable()
gibt
true
zurück), und
get_stop_source
(
)
.
stop_possible
(
)
ist
true
.
Exceptions
std::errc::resource_unavailable_try_again
oder einen anderen implementationsspezifischen Fehlerzustand repräsentieren.
Hinweise
Die Argumente für die Thread-Funktion werden durch Verschieben oder Kopieren als Wert übergeben. Wenn ein Referenzargument an die Thread-Funktion übergeben werden muss, muss es umschlossen werden (z.B. mit std::ref oder std::cref ).
Jeder Rückgabewert der Funktion wird ignoriert. Wenn die Funktion eine Exception wirft, std::terminate wird aufgerufen. Um Rückgabewerte oder Exceptions an den aufrufenden Thread zurückzugeben, std::promise oder std::async können verwendet werden.
Beispiel
#include <chrono> #include <iostream> #include <thread> #include <utility> using namespace std::literals; void f1(int n) { for (int i = 0; i < 5; ++i) { std::cout << "Thread 1 executing\n"; ++n; std::this_thread::sleep_for(10ms); } } void f2(int& n) { for (int i = 0; i < 5; ++i) { std::cout << "Thread 2 executing\n"; ++n; std::this_thread::sleep_for(10ms); } } class foo { public: void bar() { for (int i = 0; i < 5; ++i) { std::cout << "Thread 3 executing\n"; ++n; std::this_thread::sleep_for(10ms); } } int n = 0; }; class baz { public: void operator()() { for (int i = 0; i < 5; ++i) { std::cout << "Thread 4 executing\n"; ++n; std::this_thread::sleep_for(10ms); } } int n = 0; }; int main() { int n = 0; foo f; baz b; std::jthread t0; // t0 ist kein Thread std::jthread t1(f1, n + 1); // call by value std::jthread t2a(f2, std::ref(n)); // call by reference std::jthread t2b(std::move(t2a)); // t2b führt nun f2() aus. t2a ist kein Thread mehr std::jthread t3(&foo::bar, &f); // t3 führt foo::bar() auf Objekt f aus std::jthread t4(b); // t4 führt baz::operator() auf einer Kopie von Objekt b aus t1.join(); t2b.join(); t3.join(); std::cout << "Final value of n is " << n << '\n'; std::cout << "Final value of f.n (foo::n) is " << f.n << '\n'; std::cout << "Final value of b.n (baz::n) is " << b.n << '\n'; // t4 führt join bei Zerstörung aus }
Mögliche Ausgabe:
Thread 2 executing Thread 1 executing Thread 4 executing Thread 3 executing Thread 3 executing Thread 4 executing Thread 2 executing Thread 1 executing Thread 3 executing Thread 1 executing Thread 4 executing Thread 2 executing Thread 3 executing Thread 1 executing Thread 4 executing Thread 2 executing Thread 3 executing Thread 1 executing Thread 4 executing Thread 2 executing Final value of n is 5 Final value of f.n (foo::n) is 5 Final value of b.n (baz::n) is 0
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 |
|---|---|---|---|
| LWG 3476 | C++20 |
Überladung
(3)
erforderte direkt, dass (die zerfallenen Typen von)
F
und die Argumenttypen move-konstruierbar sind
|
diese Anforderungen
entfernt [1] |
- ↑ Die Move-Konstruierbarkeit ist bereits indirekt durch std::is_constructible_v vorausgesetzt.
Siehe auch
konstruiert neues
thread
Objekt
(öffentliche Elementfunktion von
std::thread
)
|
|
|
C-Dokumentation
für
thrd_create
|
|