在异常调用之后是std :: call_once保证线程的通知

Question

The standard example for std::call_once on cppreference.com describes the behavior for exceptional calls that way, that to my understanding other threads wait for the first entering the std::call_once and in case of an exception the next thread will try to execute the std::call_once . While online compilers confirm this behavior, I cannot reproduce it locally. For the minimal example

#include <iostream>
#include <thread>
#include <mutex>

std::once_flag flag;

void may_throw_function(bool do_throw)
{
  if (do_throw) {
    std::cout << "throw: call_once will retry\n";
    throw std::exception();
  }
  std::cout << "Didn't throw, call_once will not attempt again\n";
}

void do_once(bool do_throw)
{
  try {
    std::call_once(flag, may_throw_function, do_throw);
  }
  catch (...) {}
}

int main()
{
    std::thread t1(do_once, true);
    std::thread t2(do_once, true);
    std::thread t3(do_once, false);
    std::thread t4(do_once, true);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

copied from cppreference.com the execution is stuck after the first throw and runs forever

Compilation is done with g++-5 -std=c++14 source.cpp -pthread (version g++ (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609 ) or clang++-6.0 source.cpp -pthread (version clang version 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final) ).

Putting more output into the code shows, that all threads are started, but only the threads that throws first ever ends. All others seems to wait before the std::call_once statement. Hence my question: Is the notification of threads that are waiting for the first thread to finish guaranteed?

Answer 1

Is the notification of threads that are waiting for the first thread to finish guaranteed?

There is no notification involved, but if I interpret your question as:

Is t4.join() guaranteed to return?

Yes it is.

[thread.once.callonce]

 template<class Callable, class... Args> void call_once(once_flag& flag, Callable&& func, Args&&... args); 

Effects : An execution of call_once that does not call its func is a passive execution.
An execution of call_once that calls its func is an active execution. An active execution shall call INVOKE(​std::forward<Callable>(func), std::forward<Args>(args)...) .
If such a call to func throws an exception the execution is exceptional, otherwise it is returning.
An exceptional execution shall propagate the exception to the caller of call_once . Among all executions of call_once for any given once_flag : at most one shall be a returning execution; if there is a returning execution, it shall be the last active execution; and there are passive executions only if there is a returning execution .

Synchronization : For any given once_flag: all active executions occur in a total order ; completion of an active execution synchronizes with the start of the next one in this total order; and the returning execution synchronizes with the return from all passive executions.

A call_once will not be executed only if another call_once returned (meaning: did not throw). And since total order is observed, it is guaranteed that:

• t1 is an active exceptional execution or a passive execution;
• t2 is an active exceptional execution or a passive execution;
• t3 is an active returning execution;
• t4 is an active exceptional execution or a passive execution;

And since a passive execution returns, t4 is guaranteed to return.

---

Reported by user cpplearner , a bug of pthread_once make the program listed in the question hang ( demo ).