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
 
#if __DCL_WINDOWS
    #ifndef _WINDOWS_
        #error "Required windows.h, See dcl/_windows.h"
    #endif
    #if __DCL_PTHREAD
        #include <pthread.h>
    #endif
#else
    #include <bits/pthreadtypes.h>
    #define INFINITE    -1
#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; }
    
    unsigned long id() const { return __threadId; }

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

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

    static void yield();

    static unsigned long getCurrentThreadId();

    static Thread* getCurrentThread();

#if __DCL_PTHREAD
    typedef pthread_once_t  OnceType;
    enum { ONCE_INIT = 0 /* PTHREAD_ONCE_INIT */ };
#elif __DCL_WINDOWS
    typedef long                    OnceType;
    enum { ONCE_INIT = (long)0 };
#endif
    typedef void (* initRoutine)();
    static void once(OnceType& _onceControl, initRoutine _initRoutine);
 
#if __DCL_PTHREAD
    typedef pthread_key_t   KeyType;
#elif __DCL_WINDOWS
    typedef DWORD           KeyType;
#endif

    static KeyType keyCreate() __DCL_THROWS1(SysError*);

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

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

    static void* keyGetValue(KeyType _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 __DCL_WINDOWS
        HANDLE  __hEvent;
#endif
 
    __protected:
#if __DCL_PTHREAD
        int handle() { return __fds[READ_FD_INDEX]; }
#elif __DCL_WINDOWS
        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 __DCL_WINDOWS
        CRITICAL_SECTION    __cs;
#endif
 
#if __DCL_WINDOWS
    protected:
        Mutex(DWORD _dwSpinCount);
#endif
    public:
        Mutex();
        ~Mutex();
        void lock();
        bool tryLock();
        void unlock();
    };
 
#if __DCL_PTHREAD
    class DCLCAPI SpinLock
    {
    private:
        pthread_spinlock_t  __spinLock;
 
    public:
        SpinLock(bool _pshared = false);
        ~SpinLock();
        void lock();
        bool tryLock();
        void unlock();
    };
#elif __DCL_WINDOWS
    class DCLCAPI SpinLock : public Mutex
    {
    public:
        SpinLock() : Mutex(INFINITE) { }
    };
#endif
 
 
#if __DCL_PTHREAD || (__DCL_WINDOWS && _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 __DCL_WINDOWS
    #if _WIN32_WINNT >= 0x0600
        CONDITION_VARIABLE  __cond;
    #else
        Event              __cond;
    #endif
#endif
 
    public:
        CondVar();
        ~CondVar();
        void signal();
#if __DCL_PTHREAD || (__DCL_WINDOWS && _WIN32_WINNT >= 0x0600)
        void broadcast();
#endif
        
        bool wait(Mutex& _mutex, unsigned int _milliseconds = INFINITE);
#if __DCL_WINDOWS && _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
    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) : __lock(_lock)
        {
            __lock.lock();
        }
 
        ~SingleLock()
        {
            __lock.unlock();
        }
    };
 
    typedef SingleLock<Mutex>      SingleLockMutex;
    typedef SingleLock<SpinLock>    SingleLockSpin;
 
    template<typename TYPE>
    class SingleTryLock
    {
    private:
        TYPE&       __lock;         // Mutex or SpinLock
        bool    __locked;
    public:
        SingleTryLock(TYPE& _lock) : __lock(_lock)
        {
            __locked = __lock.tryLock();
        }
        ~SingleTryLock()
        {
            if (__locked)
                __lock.unlock();
        }
    };
 
    typedef SingleTryLock<Mutex>        SingleTryLockMutex;
    typedef SingleTryLock<SpinLock>  SingleTryLockSpin;
 
};
 
 
#if __DCL_WINDOWS
inline long Thread::incrementAndGet(volatile long& _n)
{
    return InterlockedIncrement(&_n);
}
 
inline long Thread::decrementAndGet(volatile long& _n)
{
    return InterlockedDecrement(&_n);
}
 
#if _WIN32_WINNT >= 0x0600
inline long long Thread::decrementAndGet(volatile long long& _n)
{
    return InterlockedDecrement64(&_n);
}
 
inline long long Thread::incrementAndGet(volatile long long& _n)
{
    return InterlockedIncrement64(&_n);
}
#endif
#endif
 
__DCL_END_NAMESPACE
 
#endif  // __DCL_THREAD_H__