std :: call_once是可重入的还是线程安全的？

Question

std :: call_once 是线程安全的,但是它也可以重入吗？

我使用VS2012(Debug和Release)进行的测试表明,std::call_once从单个线程递归调用是可以的,但如果调用是在不同的线程上进行的,则会导致死锁.这是一个已知的限制std::call_once吗？

#include "stdafx.h"

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

void Foo()
{
    std::cout << "Foo start" << std::endl;

    std::once_flag flag;
    std::call_once( flag, [](){
        std::cout << "Hello World!" << std::endl;
    });

    std::cout << "Foo end" << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
    // Single threaded Works
    {
        std::once_flag fooFlag;
        std::call_once( fooFlag, Foo);      
    }

    // Works
    // Threaded version, join outside call_once
    {
        std::once_flag fooFlag;
        std::thread t;
        std::call_once( fooFlag, [&t](){
            t = std::thread(Foo);
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }); 
        t.join();
    }

    // Dead locks
    // Threaded version, join inside call_once
    {
        std::once_flag fooFlag;
        std::call_once( fooFlag, [](){
            auto t = std::thread(Foo);
            t.join();
        });     
    }

    return 0;
}

似乎std:call_once是锁定一个静态互斥锁,在该函数退出之前不会解锁.在单线程情况下它可以工作,因为在第二次调用时线程已经有锁.在线程版本上,它将阻塞,直到第一个调用退出.

我还注意到,如果std::once_flag将Foo()函数中的标志更改为static仍然会发生死锁.

Answer 1

最接近标准的是17.6.5.8 [reentrancy]:

1 - 除非在本标准中明确指定,否则它是实现定义的,可以递归地重新输入标准C++库中的哪些函数.

不幸的是,规范call_once并没有说明它是递归的(或者是跨线程递归的),并且线程支持库前导码也没有说明这个主题.

也就是说,VC++实现显然不是最理想的,特别是因为可以编写用户版本的call_once使用condition_variable:

#include <mutex>
#include <condition_variable>

struct once_flag {
  enum { INIT, RUNNING, DONE } state = INIT;
  std::mutex mut;
  std::condition_variable cv;
};
template<typename Callable, typename... Args>
void call_once(once_flag &flag, Callable &&f, Args &&...args)
{
  {
    std::unique_lock<std::mutex> lock(flag.mut);
    while (flag.state == flag.RUNNING) {
      flag.cv.wait(lock);
    }
    if (flag.state == flag.DONE) {
      return;
    }
    flag.state = flag.RUNNING;
  }
  try {
    f(args...);
    {
      std::unique_lock<std::mutex> lock(flag.mut);
      flag.state = flag.DONE;
    }
    flag.cv.notify_all();
  }
  catch (...) {
    {
      std::unique_lock<std::mutex> lock(flag.mut);
      flag.state = flag.INIT;
    }
    flag.cv.notify_one();
    throw;
  }
}

请注意,这是一个细粒度的实现; 也可以编写一个粗粒度的实现,在所有一次标志中使用一对互斥和条件变量,但是你需要确保在抛出异常时通知所有等待的线程(例如,libc ++这样做) .

为了提高效率,您可以制作once_flag::state原子并使用双重检查锁定; 为简洁起见,这里省略了.