为什么std :: thread在其构造函数中等待？

Question

The current implementation of the STL in Microsoft Visual C++ 2015 seems to disallow any lock-free environment to start a thread due to a mutex wait in the constructor.

void _Launch(_Thrd_t *_Thr)
    {   // launch a thread
    _Thrd_startX(_Thr, _Call_func, this);
    while (!_Started)
        _Cnd_waitX(_Cond, _Mtx); // <-- Why?
    }

template<class _Target> inline
    void _Launch(_Thrd_t *_Thr, _Target&& _Tg)
    {   // launch a new thread
    _LaunchPad<_Target> _Launcher(_STD forward<_Target>(_Tg));
    _Launcher._Launch(_Thr);
    }

explicit thread(_Fn&& _Fx, _Args&&... _Ax)
    {   // construct with _Fx(_Ax...)
    _Launch(&_Thr,
        _STD make_unique<tuple<decay_t<_Fn>, decay_t<_Args>...> >(
            _STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...));
    }

Can anybody tell me why this wait is needed?

I'm asking, because I currently examine a system that sometimes needs over 500ms to construct a std::thread but never shows this delay with using CreateThread .

Answer 1

_LaunchPad<_Target> _Launcher(_STD forward<_Target>(_Tg));

_Launcher is on the stack and is passed to the new thread. Why? I don't know, but this makes it important that _Launcher not go out of scope until the new thread is done with it. The wait is likely there to guarantee this.