NAME¶

std::jthread::join - std::jthread::join

Synopsis¶

void join(); (since C++20)

Blocks the current thread until the thread identified by *this finishes its
execution.

The completion of the thread identified by *this synchronizes with the corresponding
successful return from join().

No synchronization is performed on *this itself. Concurrently calling join() on the
same jthread object from multiple threads constitutes a data race that results in
undefined behavior.

Parameters¶

(none)

Return value¶

(none)

Postconditions¶

joinable() is false.

Exceptions¶

std::system_error if an error occurs.

Error conditions

* resource_deadlock_would_occur if this->get_id() == std::this_thread::get_id()
(deadlock detected).
* no_such_process if the thread is not valid.
* invalid_argument if joinable() is false.

Example¶

// Run this code

#include <chrono>
#include <iostream>
#include <thread>

void foo()
{
// simulate expensive operation
std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
// simulate expensive operation
std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
std::cout << "starting first helper...\n";
std::jthread helper1(foo);

std::cout << "starting second helper...\n";
std::jthread helper2(bar);

std::cout << "waiting for helpers to finish..." << std::endl;
helper1.join();
helper2.join();

std::cout << "done!\n";
}

Output:¶

starting first helper...
starting second helper...
waiting for helpers to finish...
done!

References¶

* C++23 standard (ISO/IEC 14882:2023):

* 33.4.4.3 Members [thread.jthread.mem]
* C++20 standard (ISO/IEC 14882:2020):

* 32.4.3.2 Members [thread.jthread.mem]

See also¶

detach permits the thread to execute independently from the thread handle
(public member function)
checks whether the thread is joinable, i.e. potentially running in parallel
joinable context
(public member function)
C documentation for
thrd_join