thread Class Reference

Classes
class	id

Public Types
typedef void *	native_handle_type

Public Member Functions
	thread () _NOEXCEPT
template<class _Fn , class... _Args, class = typename enable_if< !is_same<typename decay<_Fn>::type, thread>::value>::type>
	thread (_Fn &&_Fx, _Args &&..._Ax)
	~thread () _NOEXCEPT
	thread (thread &&_Other) _NOEXCEPT
thread &	operator= (thread &&_Other) _NOEXCEPT
	thread (const thread &)=delete
thread &	operator= (const thread &)=delete
void	swap (thread &_Other) _NOEXCEPT
bool	joinable () const _NOEXCEPT
void	join ()
void	detach ()
id	get_id () const _NOEXCEPT
native_handle_type	native_handle ()

Static Public Member Functions
static unsigned int	hardware_concurrency () _NOEXCEPT

Private Member Functions
thread &	_Move_thread (thread &_Other)

Private Attributes
_Thrd_t	_Thr

Member Typedef Documentation

typedef void* thread::native_handle_type

Constructor & Destructor Documentation

thread::thread ( )

inline

        {   // construct with no thread
        _Thr_set_null(_Thr);
        }

template<class _Fn , class... _Args, class = typename enable_if< !is_same<typename decay<_Fn>::type, thread>::value>::type>

thread::thread ( _Fn &&  _Fx, _Args &&...  _Ax  )

inlineexplicit

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

thread::~thread ( )

inline

        {   // clean up
        if (joinable())
            _XSTD terminate();
        }

thread::thread ( thread &&  _Other )

inline

        : _Thr(_Other._Thr)
        {   // move from _Other
        _Thr_set_null(_Other._Thr);
        }

thread::thread ( const thread &  )

delete

Member Function Documentation

thread& thread::_Move_thread ( thread &  _Other )

inlineprivate

        {   // move from _Other
        if (joinable())
            _XSTD terminate();
        _Thr = _Other._Thr;
        _Thr_set_null(_Other._Thr);
        return (*this);
        }

void thread::detach ( )

inline

        {   // detach thread
        if (!joinable())
            _Throw_Cpp_error(_INVALID_ARGUMENT);
        _Thrd_detachX(_Thr);
        _Thr_set_null(_Thr);
        }

thread::id thread::get_id ( ) const

inline

    {   // return id for this thread
    return (_Thr_val(_Thr));
    }

static unsigned int thread::hardware_concurrency ( )

inlinestatic

        {   // return number of hardware thread contexts
        return (_Thrd_hardware_concurrency());
        }

void thread::join ( )

inline

    {   // join thread
    if (!joinable())
        _Throw_Cpp_error(_INVALID_ARGUMENT);
    const bool _Is_null = _Thr_is_null(_Thr);   // Avoid Clang -Wparentheses-equality
    if (_Is_null)
        _Throw_Cpp_error(_INVALID_ARGUMENT);
    if (get_id() == _STD this_thread::get_id())
        _Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
    if (_Thrd_join(_Thr, 0) != _Thrd_success)
        _Throw_Cpp_error(_NO_SUCH_PROCESS);
    _Thr_set_null(_Thr);
    }

bool thread::joinable ( ) const

inline

        {   // return true if this thread can be joined
        return (!_Thr_is_null(_Thr));
        }

native_handle_type thread::native_handle ( )

inline

        {   // return Win32 HANDLE as void *
        return (_Thr._Hnd);
        }

thread& thread::operator= ( thread &&  _Other )

inline

        {   // move from _Other
        return (_Move_thread(_Other));
        }

thread& thread::operator= ( const thread &  )

delete

void thread::swap ( thread &  _Other )

inline

        {   // swap with _Other
        _STD swap(_Thr, _Other._Thr);
        }

Member Data Documentation

_Thrd_t thread::_Thr

private

---

The documentation for this class was generated from the following file:

• VS2015/inc/thread