std::jthread::join(3)

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 <iostream>
 #include <thread>
 #include <chrono>
 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++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)