std::jthread:: jthread
|
jthread
(
)
noexcept
;
|
(1) | (depuis C++20) |
|
jthread
(
jthread
&&
other
)
noexcept
;
|
(2) | (depuis C++20) |
|
template
<
class
F,
class
...
Args
>
explicit jthread ( F && f, Args && ... args ) ; |
(3) | (depuis C++20) |
|
jthread
(
const
jthread
&
)
=
delete
;
|
(4) | (depuis C++20) |
Construit un nouvel objet
std::jthread
.
std::jthread
qui ne représente pas un thread.
std::jthread
pour représenter le thread d'exécution qui était représenté par
other
. Après cet appel,
other
ne représente plus un thread d'exécution.
std::jthread
et l'associe à un thread d'exécution.
Le nouveau thread d'exécution commence par exécuter :
std::
invoke
(
decay-copy
(
std::
forward
<
F
>
(
f
)
)
, get_stop_token
(
)
,
decay-copy
(
std::
forward
<
Args
>
(
args
)
)
...
)
|
(jusqu'en C++23) |
|
std::
invoke
(
auto
(
std::
forward
<
F
>
(
f
)
)
, get_stop_token
(
)
,
|
(depuis C++23) |
si l'expression ci-dessus est bien formée, sinon commence par exécuter :
std::
invoke
(
decay-copy
(
std::
forward
<
F
>
(
f
)
)
,
decay-copy
(
std::
forward
<
Args
>
(
args
)
)
...
)
.
|
(jusqu'en C++23) |
|
std::
invoke
(
auto
(
std::
forward
<
F
>
(
f
)
)
,
|
(depuis C++23) |
std::jthread
.
- 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
objets ne peuvent représenter le même thread d'exécution.
Table des matières |
Paramètres
| other | - |
autre objet
std::jthread
pour construire cet objet
std::jthread
avec
|
| f | - | Callable objet à exécuter dans le nouveau thread |
| args | - | arguments à passer à la nouvelle fonction |
Postconditions
get_id()
égal à
std::jthread::id()
(c'est-à-dire que
joinable()
retourne
false
) et
get_stop_source
(
)
.
stop_possible
(
)
est
false
.
get_id()
retourne la valeur de
other.
get_id
(
)
avant le début de la construction.
get_id()
différent de
std::jthread::id()
(c'est-à-dire que
joinable()
renvoie
true
), et
get_stop_source
(
)
.
stop_possible
(
)
est
true
.
Exceptions
std::errc::resource_unavailable_try_again
ou une autre condition d'erreur spécifique à l'implémentation.
Notes
Les arguments de la fonction de thread sont déplacés ou copiés par valeur. Si un argument de référence doit être passé à la fonction de thread, il doit être encapsulé (par exemple avec std::ref ou std::cref ).
Toute valeur de retour de la fonction est ignorée. Si la fonction lance une exception, std::terminate est appelé. Afin de transmettre les valeurs de retour ou les exceptions au thread appelant, std::promise ou std::async peuvent être utilisés.
Exemple
#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 n'est pas un thread std::jthread t1(f1, n + 1); // passage par valeur std::jthread t2a(f2, std::ref(n)); // passage par référence std::jthread t2b(std::move(t2a)); // t2b exécute maintenant f2(). t2a n'est plus un thread std::jthread t3(&foo::bar, &f); // t3 exécute foo::bar() sur l'objet f std::jthread t4(b); // t4 exécute baz::operator() sur une copie de l'objet b t1.join(); t2b.join(); t3.join(); std::cout << "Valeur finale de n est " << n << '\n'; std::cout << "Valeur finale de f.n (foo::n) est " << f.n << '\n'; std::cout << "Valeur finale de b.n (baz::n) est " << b.n << '\n'; // t4 se joint lors de la destruction }
Sortie possible :
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
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement tel que publié | Comportement correct |
|---|---|---|---|
| LWG 3476 | C++20 |
la surcharge
(3)
exigeait directement que (les types décomposés de)
F
et les types d'arguments soient déplaçables
|
ces exigences ont été
supprimées [1] |
- ↑ La constructibilité par déplacement est déjà indirectement requise par std::is_constructible_v .
Voir aussi
construit un nouvel objet
thread
(fonction membre publique de
std::thread
)
|
|
|
Documentation C
pour
thrd_create
|
|