threads.hpp

浏览该文件的文档.

#ifndef __THREADS_HPP__
#define __THREADS_HPP__
//
// threads 提供线程相关的功能
//

namespace winux
{
// 类型定义
#if defined(OS_WIN)
typedef DWORD pid_t;
#else
typedef int pid_t;
#endif

//=========================================================================================
class ThreadSysError : public Error
{
public:
    ThreadSysError( int errCode, AnsiString const & errStr ) throw() : Error( errCode, errStr ) {  }
    int getErrCode() const throw() { return this->getErrType(); }
};

//=========================================================================================
// 线程相关错误返回值为errno.h定义的错误码
//=========================================================================================

enum SchedulePolicy
{
    schedOther = 0, 
    schedFifo, 
    schedRr, 
    schedMin = schedOther,
    schedMax = schedRr
};

struct ScheduleParam
{
    int schedPriority;
};

struct WINUX_DLL Schedule
{
#ifdef Yield
#undef Yield
#endif
    static int Yield(void);
    static int GetPriorityMin( SchedulePolicy policy );
    static int GetPriorityMax( SchedulePolicy policy );
    static void SetScheduler( pid_t pid, SchedulePolicy policy );
    static SchedulePolicy GetScheduler( pid_t pid );
};

class WINUX_DLL ThreadAttr
{
public:
    explicit ThreadAttr( bool isCreate = true );
    ~ThreadAttr();

    ThreadAttr( ThreadAttr && other );
    ThreadAttr & operator = ( ThreadAttr && other );

    int create();

    int destroy();

    operator bool() const;

public:
    //attributes:

    enum DetachStateType
    {
        threadCreateJoinable = 0,  
        threadCreateDetached = 1,  
    };
    void setDetachState( DetachStateType detachState = threadCreateJoinable );
    DetachStateType getDetachState() const;

    void setStackSize( size_t stackSize );
    size_t getStackSize() const;

    void setSchedParam( ScheduleParam const & param );
    ScheduleParam getSchedParam() const;

    void setSchedPolicy( SchedulePolicy policy );
    SchedulePolicy getSchedPolicy() const;

private:
    PlainMembers<struct ThreadAttr_Data, 64> _self;
    friend class Thread;

    DISABLE_OBJECT_COPY(ThreadAttr)
};

class WINUX_DLL ThreadId
{
public:
    ThreadId();
    ~ThreadId();
    ThreadId( ThreadId const & other );
    ThreadId & operator = ( ThreadId const & other );
    ThreadId( ThreadId && other );
    ThreadId & operator = ( ThreadId && other );

    bool operator == ( ThreadId const & other ) const;
    bool operator != ( ThreadId const & other ) const { return !this->operator == (other); }

private:
    PlainMembers<struct ThreadId_Data, 24> _self;

    friend class Thread;
};

class ThreadGroup;
class WINUX_DLL Thread
{
public:
    typedef void * (* ThreadFuncPtr)( void * param );

public:
    static ThreadId Self();

    static void Exit( void * exitVal = NULL );

    static void * Join( Thread & otherThread );

    // attributes
    static void SetConcurrency( int newLevel );
    static int GetConcurrency( void );

private:
    // 默认线程处理函数, param被传入Thread对象, 调用thObj->run()
    static void * _ThreadDefaultFunc( void * param );

public:
    explicit Thread( bool isStartup = false ) : _param(nullptr), _attr(false), _exitVal(nullptr), _deleter(nullptr), _group(nullptr), _isRunning(false)
    {
        if ( isStartup ) this->startup();
    }

    template < typename _Fx, typename... _ArgType >
    explicit Thread( bool isStartup, _Fx routine, _ArgType&&... arg ) : _param(nullptr), _attr(false), _exitVal(nullptr), _deleter(nullptr), _group(nullptr), _isRunning(false)
    {
        this->setRunable( routine, std::forward<_ArgType>(arg)... );
        if ( isStartup ) this->startup();
    }

    virtual ~Thread();

    Thread( Thread && other );

    Thread & operator = ( Thread && other );

    int startup();

    template < typename _Fx, typename... _ArgType >
    int startup( _Fx routine, _ArgType&&... arg )
    {
        this->setRunable( routine, std::forward<_ArgType>(arg)... );
        return this->startup();
    }

    int startupEx( ThreadFuncPtr startRoutine, void * param );

    void * joined();

    int detach();

public:
    //attributes:

    void setSchedParam( SchedulePolicy policy, int priority );
    void getSchedParam( SchedulePolicy * policy, int * priority ) const;

    ThreadAttr & attr();

    template < typename _Fx, typename... _ArgType >
    Thread & setRunable( _Fx routine, _ArgType&&... arg )
    {
        this->_runable.attachNew( NewRunable( routine, std::forward<_ArgType>(arg)... ) );
        return *this;
    }

    Thread & setDeleter( SimpleDeleterContext * deleter = NULL )
    {
        _deleter = deleter;
        return *this;
    }

    Thread & setDefaultDeleter() { return this->setDeleter( new SimpleDefaultDeleterContext<Thread*>(this) ); }

    template < typename _Dt >
    Thread & setCustomDeleter( _Dt fn ) { return this->setDeleter( new SimpleCustomDeleterContext< Thread*, _Dt >( this, fn ) ); }

    void * getExitVal() const { return _exitVal; }
    Thread & setExitVal( void * exitVal )
    {
        _exitVal = exitVal;
        return *this;
    }

    ThreadId get() const
    {
        return _threadId;
    }

protected:
    virtual void run();
    struct _ThreadFuncParam * _param;   

private:
    ThreadAttr _attr;                   
    void * _exitVal;                    
    SimpleDeleterContext * _deleter;    
    ThreadGroup * _group;               
    bool _isRunning;                    
    ThreadId _threadId;                 
    SimplePointer<Runable> _runable;    

    friend class ThreadGroup;

    DISABLE_OBJECT_COPY(Thread)
};

//=========================================================================================
class WINUX_DLL MutexAttr
{
public:
    explicit MutexAttr( bool isCreate = true );
    ~MutexAttr();

    MutexAttr( MutexAttr && other );
    MutexAttr & operator = ( MutexAttr && other );

    int create();

    int destroy();

    operator bool() const;

public:
    enum MutexType
    {
        mtxNormal, 
        mtxRecursive, 
        mtxErrorCheck,
        mtxDefault
    };
    int setType( MutexType type );

    MutexType getType() const;

private:
    PlainMembers<struct MutexAttr_Data, 16> _self;
    friend class Mutex;

    DISABLE_OBJECT_COPY(MutexAttr)
};

class WINUX_DLL Mutex : public winux::ILockObj
{
public:
    explicit Mutex( bool isCreate = false );
    ~Mutex();

    Mutex( Mutex && other );
    Mutex & operator = ( Mutex && other );

    virtual int create();

    int destroy();

    bool lock();
    bool tryLock();
    bool unlock();

    MutexAttr & attr();
private:
    MutexAttr _attr; 
    PlainMembers<struct Mutex_Data, 48> _self;
    friend class Condition;

    DISABLE_OBJECT_COPY(Mutex)
};

class WINUX_DLL RecursiveMutex : public Mutex
{
public:
    explicit RecursiveMutex( bool isCreate = false );
    int create() override;
};

//=========================================================================================
class WINUX_DLL ConditionAttr
{
public:
    explicit ConditionAttr( bool isCreate = true );
    ~ConditionAttr();

    ConditionAttr( ConditionAttr && other );
    ConditionAttr & operator = ( ConditionAttr && other );

    int create();

    int destroy();

    operator bool() const;

private:
    PlainMembers<struct ConditionAttr_Data, 16> _self;
    friend class Condition;

    DISABLE_OBJECT_COPY(ConditionAttr)
};

class WINUX_DLL Condition
{
public:
    explicit Condition( bool isCreate = false );
    ~Condition();

    Condition( Condition && other );
    Condition & operator = ( Condition && other );

    int create();

    int destroy();

    bool wait( Mutex & mutex, double sec = -1 );

    template < typename _Predicate >
    bool waitUntil( _Predicate pred, Mutex & mutex, double sec = -1 )
    {
        while ( !pred() )
            if ( !this->wait( mutex, sec ) )
                return pred();
        return true;
    }

    int notify();

    int notifyAll();

    ConditionAttr & attr();

private:
    ConditionAttr _attr;
    PlainMembers<struct Condition_Data, 56> _self;
    DISABLE_OBJECT_COPY(Condition)
};

//===========================================================================================
class WINUX_DLL TlsKey
{
public:
    explicit TlsKey( void (*destructor)( void *pv ) = NULL );
    ~TlsKey();

    TlsKey( TlsKey && other );
    TlsKey & operator = ( TlsKey && other );

    int create( void (*destructor)( void *pv ) = NULL );

    int destroy();

    void * get() const;

private:
    PlainMembers<struct TlsKey_Data, 8> _self;

    friend class TlsVar;
    DISABLE_OBJECT_COPY(TlsKey)
};

class WINUX_DLL TlsVar
{
public:
    explicit TlsVar( TlsKey & tlsKey );
    ~TlsVar();

    TlsVar( TlsVar && other );
    TlsVar & operator = ( TlsVar && other );

    void * get();
    void * get() const;
    void set( void * v );

    template < typename _Ty >
    _Ty get() { return reinterpret_cast<_Ty>( this->get() ); }
    template < typename _Ty >
    _Ty get() const { return reinterpret_cast<_Ty>( this->get() ); }

    template < typename _Ty >
    void set( _Ty v ) { this->set( reinterpret_cast<void*>(v) ); }

    template < typename _Ty >
    _Ty & ref() { return *reinterpret_cast<_Ty*>( this->get() ); }
    template < typename _Ty >
    _Ty const & ref() const { return *reinterpret_cast<_Ty*>( this->get() ); }

private:
    TlsKey * _tlsKey;
    DISABLE_OBJECT_COPY(TlsVar)
};

//===========================================================================================

class WINUX_DLL ThreadGroup
{
public:

    ThreadGroup() : _mtxGroup(true), _cdtGroup(true)
    {
    }

    template < typename _Fx, typename... _ArgType >
    ThreadGroup( size_t count, _Fx fn, _ArgType&&... arg ) : _mtxGroup(true), _cdtGroup(true)
    {
        for ( size_t i = 0; i < count; i++ )
        {
            Thread * p = new Thread( false, fn, std::forward<_ArgType>(arg)... );
            p->_group = this;
            _threads.emplace_back(p);
        }
    }

    virtual ~ThreadGroup()
    {
    }

    ThreadGroup( ThreadGroup && other ) : _mtxGroup( std::move(other._mtxGroup) ), _cdtGroup( std::move(other._cdtGroup) ), _threads( std::move(other._threads) )
    {
    }

    ThreadGroup & operator = ( ThreadGroup && other )
    {
        if ( this != &other )
        {
            // 先释放自身
            this->wait();

            _mtxGroup = std::move(other._mtxGroup);
            _cdtGroup = std::move(other._cdtGroup);
            _threads = std::move(other._threads);
        }
        return *this;
    }

    ThreadGroup & destroy();

    template < typename _Fx, typename... _ArgType >
    ThreadGroup & create( size_t count, _Fx fn, _ArgType&&... arg )
    {
        this->destroy();

        for ( size_t i = 0; i < count; i++ )
        {
            Thread * p = new Thread( false, fn, std::forward<_ArgType>(arg)... );
            p->_group = this;
            _threads.emplace_back(p);
        }
        return *this;
    }

    template < class _ThreadCls >
    ThreadGroup & create( size_t count )
    {
        this->destroy();

        for ( size_t i = 0; i < count; i++ )
        {
            Thread * p = new _ThreadCls();
            p->_group = this;
            _threads.emplace_back(p);
        }
        return *this;
    }

    ThreadGroup & startup();

    bool wait( double sec = -1 );

private:
    static void * _ThreadGroupDefaultFunc( void * param );

    Mutex _mtxGroup; // 互斥量保护数据
    Condition _cdtGroup; // 用于判断组中线程是否全部运行完毕
    std::vector< SimplePointer<Thread> > _threads;

    DISABLE_OBJECT_COPY(ThreadGroup)
};


} // namespace winux

#endif // __THREADS_HPP__