thread Class Reference

Classes
class	id

Public Types
typedef void *	native_handle_type

Public Member Functions
	thread () _NOEXCEPT
template<class _Fn , class... _Args>
	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>

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

inlineexplicit

        {   // construct with _Fx(_Ax...)
        _Launch(&_Thr,
             _STD bind(_Decay_copy(_STD forward<_Fn>(_Fx)),
                _Decay_copy(_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 (id(*this));
    }

static unsigned int thread::hardware_concurrency ( )

inlinestatic

        {   // return number of hardware thread contexts
        return (::Concurrency::details::_GetConcurrency());
        }

void thread::join ( )

inline

    {   // join thread
    if (!joinable())
        _Throw_Cpp_error(_INVALID_ARGUMENT);
    if (_Thr_is_null(_Thr))
        _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:

• VS2013/inc/thread