父线程join（）：在子级完成之前阻止？

Question

I have a C++ class that does some multi-threading. Consider the pseudo-code below:

void MyClass::Open() {
  loop_flag =  true;
  // create consumer_thread (infinite loop)
  // create producer_thread (infinite loop)
}
void MyClass::Close() {
  loop_flag = false;
  // join producer_thread
  // join consumer_thread
}
MyClass::~MyClass() {
  Close();
  // do other stuff here
}

Note that consumer_thread, producer_thread, and their associated functions are all encapsulated in MyClass. The caller has no clue that their calls are multi-threaded and what's going on in the background.

Now, the class is part of a larger program. The program has some initial multi-threading to handle configuration of the system since there's a ton of stuff happening at once.

Like this (pseudo-code):

int main() {
  // create config_thread1 (unrelated to MyClass)
  // create thread for MyClass::Open()
  // ...
  // join all spawned configuration threads
}

So my question is, when I call join() for the thread linked to MyClass::Open() (ie, the configuration thread spawned in main()), what happens? Does it join() immediately (since the MyClass::Open() function just returns after creation of producer_thread and consumer_thread) or does it wait for producer_thread and consumer_thread to finish (and therefore hangs my program).

Thanks in advance for the help. In terms of implementation details, I'm using Boost threads on a Linux box.

Edited to add this diagram:

 main()
 |
 |
 |
 |--->configuration_thread (that runs MyClass::Open())
   |
   |
   |----> producer_thread
   |----> consumer_thread

If I call join() on configuration_thread(), does it wait until producer_thread() and consumer_thread() are finished or does it return immediately (and producer_thread() and consumer_thread() continue to run)?

Answer 1

A (non detached) thread will be joignable, even after having returned from the function it was set to run, until it has been joined. Example:

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

using namespace std;

void foo(){
    std::cout << "helper: I'm done\n";
}

 int main(){

    cout << "starting helper...\n";
    thread helper(foo);

    this::thread::sleep_for(std::chrono::seconds(5));

     cout << "helper still joignable?..." << (helper.joignable()?"yes!":"no...:(") << "\n";

    helper.join();
    cout << "helper joined!";

    cout << "helper still joignable?..." << (helper.joignable()?"really?":"not anymore!") << "\n";

    cout << "done!\n";

}

Output:

starting helper...
helper: I'm done
still joinable?...yes!
helper joined!
still joinable?...not anymore!
done!

As for how much time the join method takes, I don't think this is specified, but surely it doesn't't have to wait for all the other threads to finish, or it would mean that only one thread would be able to join all the others.

From §30.3.5:

void Join();

Requires: joinable() is true

Effects: Blocks until the thread represented by *this had completed.

Synchronization: The completion of the thread represented by *this synchronises with the corresponding successful join() return. [ Note: Operations on *this are not synchronised. * -- end note*]

[...]