<thread>

public member function
<thread>

std::thread::join

void join();
Join thread
The function returns when the thread execution has completed.

This synchronizes the moment this function returns with the completion of all the operations in the thread: This blocks the execution of the thread that calls this function until the function called on construction returns (if it hasn't yet).

After a call to this function, the thread object becomes non-joinable and can be destroyed safely.

Parameters

none

Return value

none

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// example for thread::join
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
 
void pause_thread(int n) 
{
  std::this_thread::sleep_for (std::chrono::seconds(n));
  std::cout << "pause of " << n << " seconds ended\n";
}
 
int main() 
{
  std::cout << "Spawning 3 threads...\n";
  std::thread t1 (pause_thread,1);
  std::thread t2 (pause_thread,2);
  std::thread t3 (pause_thread,3);
  std::cout << "Done spawning threads. Now waiting for them to join:\n";
  t1.join();
  t2.join();
  t3.join();
  std::cout << "All threads joined!\n";

  return 0;
}

Output (after 3 seconds):
Spawning 3 threads...
Done spawning threads. Now waiting for them to join:
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
All threads joined!


Data races

The object is modified.
Note that any operations on the thread object itself are not synchronized (unlike the operations within the thread it represents).

Exception safety

Basic guarantee: if an exception is thrown by this member function, the thread object is left in a valid state.

If the call fails, a system_error exception is thrown:
exception typeerror conditiondescription
system_errorerrc::invalid_argument- The thread object is not joinable
system_errorerrc::no_such_process- The thread object is not valid
system_errorerrc::resource_deadlock_would_occur- The current thread is the same as the thread attempted to join, or
- A deadlock was detected (implementations may detect certain cases of deadlock).

Note that if the thread represented by the object terminates with an uncaught exception, this cannot be caught by the current thread, and terminate() is automatically called.

See also