Thread.h

Go to the documentation of this file.

#ifndef __DCL_THREAD_H__
#define __DCL_THREAD_H__    20110109
 
#ifndef __DCL_CONFIG_H__
#include <dcl/Config.h>
#endif
 
#ifdef __WINNT__
    #if __DCL_PTHREAD
        #include <pthread.h>
        #define INFINITE    (-1)
        #define THREAD_ONCE_INIT PTHREAD_ONCE_INIT
        typedef pthread_once_t  thread_once_t;
        typedef pthread_key_t   thread_key_t;
    #else
        #ifndef _WINDOWS_
            #error "Required windows.h, See dcl/_windows.h"
        #endif
        #if 0
            #include <synchapi.h>
        #endif
        #define THREAD_ONCE_INIT INIT_ONCE_STATIC_INIT
        typedef INIT_ONCE   thread_once_t;
        typedef DWORD       thread_key_t;
    #endif
#else
    #if defined(__ANDROID__)
        #include <bits/pthread_types.h>
    #elif !defined(__DEFINED_pthread_t) && defined(__linux__)
        #include <bits/pthreadtypes.h>
    #elif defined(__APPLE__)
        #include <sys/_pthread/_pthread_types.h>
    #else
        #include <pthread.h>
    #endif
    #define INFINITE    (-1)
    #define THREAD_ONCE_INIT PTHREAD_ONCE_INIT
    typedef pthread_once_t  thread_once_t;
    typedef pthread_key_t   thread_key_t;
#endif
 
#ifndef __DCL_OBJECT_H__
#include <dcl/Object.h>
#endif
#ifndef __DCL_STRING_H__
#include <dcl/String.h>
#endif
 
__DCL_BEGIN_NAMESPACE

class SysError;
 
class DCLCAPI Thread : public Object
{
    DECLARE_CLASSINFO(Thread)
public:
    virtual String toString() const;

    Thread(const char_t* _name = NULL);

    void start() __DCL_THROWS1(SysError*);

    int join();

    bool started() const { return __threadId != 0; }

    thread_t thread() const { return __threadId; }

    const String& name() const { return __name; }
 
protected:
    virtual bool init();

    virtual int run() = 0;
 
private:
    thread_t        __threadId;
    String          __name;
 
#if __DCL_PTHREAD
    static void* startRoutine(void* _pThread);
#elif defined(__WINNT__)
    HANDLE          __hThread;
    static DWORD WINAPI startRoutine(void* _pThread);
#endif
 
public:
    static void sleep(unsigned int _mills); 

    static void yield();

    static thread_t self();

    static Thread* getSelfThread();

    typedef void (* initRoutine)();
    static void once(thread_once_t& _onceControl, initRoutine _initRoutine);

    static thread_key_t keyCreate() __DCL_THROWS1(SysError*);

    static void keyDelete(thread_key_t _key) __DCL_THROWS1(SysError*);

    static void keySetValue(thread_key_t _key, void* _value) __DCL_THROWS1(SysError*);

    static void* keyGetValue(thread_key_t _key) __DCL_THROWS1(SysError*);

    static void crtLock(const void* _p);
    static void crtUnlock(const void* _p);
 
    static long incrementAndGet(volatile long& _n);
    static long long incrementAndGet(volatile long long& _n);
    static long decrementAndGet(volatile long& _n);
    static long long decrementAndGet(volatile long long& _n);
 
public:
    class DCLCAPI Event
    {
    private:
#if __DCL_PTHREAD
        enum { READ_FD_INDEX = 0 };
        int         __fds[2];
#elif defined(__WINNT__)
        HANDLE  __hEvent;
#endif
 
    _PROTECTED:
#if __DCL_PTHREAD
        int handle() { return __fds[READ_FD_INDEX]; }
#elif defined(__WINNT__)
        HANDLE handle() { return __hEvent; }
#endif
 
    public:
        Event();
        ~Event();
        void set();
        void reset();

        bool wait(unsigned int _milliseconds = INFINITE);
        bool isWaiting()    { return __bWaiting; }
    private:
        volatile bool __bWaiting;
    };
 
    class DCLCAPI Mutex
    {
    private:
#if __DCL_PTHREAD
        pthread_mutex_t     __mutex;
#elif defined(__WINNT__)
        CRITICAL_SECTION    __cs;
#endif
        volatile thread_t   __locker;
 
#ifdef __WINNT__
    protected:
        Mutex(DWORD _dwSpinCount);
#endif
    public:
        Mutex();
        ~Mutex();
        void lock();
        bool tryLock();
        void unlock();
        thread_t locker() const {
            return __locker;
        }
    };
 
#if __DCL_PTHREAD && !defined(__APPLE__)
    class DCLCAPI SpinLock
    {
    private:
        pthread_spinlock_t  __spinLock;
        volatile pthread_t  __locker;
 
    public:
        SpinLock(bool _pshared = false);
        ~SpinLock();
        void lock();
        bool tryLock();
        void unlock();
        pthread_t locker() const {
            return __locker;
        }
    };
#elif defined(__WINNT__)
    class DCLCAPI SpinLock : public Mutex
    {
    public:
        SpinLock() : Mutex(INFINITE) { }
    };
#endif
 
#if __DCL_PTHREAD || (defined(__WINNT__) && _WIN32_WINNT >= 0x0600)
    class DCLCAPI ReadWriteLock
    {
    private:
#if __DCL_PTHREAD
        pthread_rwlock_t    __rwlock;
#else
        SRWLOCK             __srwlock;
#endif
 
    public:
        ReadWriteLock();
        ~ReadWriteLock();
        void readLock();        // WINNT AcquireSRWLockShared
        void writeLock();       // WINNT AcquireSRWLockExclusive
#if __DCL_PTHREAD
        bool tryReadLock();
        bool tryWriteLock();
        void unlock();
#else
        void readUnlock();      // WINNT ReleaseSRWLockShared
        void writeUnlock();     // WINNT ReleaseSRWLockExclusive
#endif
    };
#endif

    class DCLCAPI CondVar
    {
    private:
#if __DCL_PTHREAD
        pthread_cond_t      __cond;
#elif defined(__WINNT__)
    #if _WIN32_WINNT >= 0x0600
        CONDITION_VARIABLE  __cond;
    #else
        Event              __cond;
    #endif
#endif
 
    public:
        CondVar();
        ~CondVar();
        void signal();
#if __DCL_PTHREAD || (defined(__WINNT__) && _WIN32_WINNT >= 0x0600)
        void broadcast();
#endif

        bool wait(Mutex& _mutex, unsigned int _milliseconds = INFINITE);
#if defined(__WINNT__) && _WIN32_WINNT >= 0x0600
        bool wait(ReadWriteLock& _lock, bool shared, unsigned int _milliseconds = INFINITE);
#endif
        bool isWaiting()   { return __bWaiting; }
    private:
        volatile bool       __bWaiting;
    };
 
#if __DCL_PTHREAD && !defined(__APPLE__)
    class DCLCAPI Barrier
    {
    private:
        pthread_barrier_t   __barrier;
 
    public:
        Barrier(unsigned int _count);
        ~Barrier();
        void wait();
    };
#endif
 
    template<typename TYPE>
    class SingleLock
    {
    private:
        TYPE*       __lock;     // Mutex or SpinLock
 
    public:
        SingleLock(TYPE& _lock);
        ~SingleLock();
    };
 
    typedef SingleLock<Mutex>      SingleLockMutex;
    #ifndef __APPLE__
    typedef SingleLock<SpinLock>    SingleLockSpin;
    #endif
};
 
template<typename TYPE>
inline Thread::SingleLock<TYPE>::SingleLock(TYPE& _lock)
{
    if (_lock.locker() != Thread::self()) {
        __lock = &_lock;
        __lock->lock();
    }
    else {
        __lock = NULL;
    }
}
 
template<typename TYPE>
inline Thread::SingleLock<TYPE>::~SingleLock()
{
    if (__lock) {
        __lock->unlock();
    }
}
 
__DCL_END_NAMESPACE
 
#endif  // __DCL_THREAD_H__