lib/threadutils.h

#ifndef __THREADUTILS_H__
#define __THREADUTILS_H__

#include <stdint.h>
#include <queue>
#include <map>
#include <set>

#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif

#include "stm_export.h"
#include <iostream>

namespace thread {

#ifdef _WIN32

struct _STM_SIGNAL
{
    HANDLE handles[2];
};

/*struct _STM_MUTEX
{

}*/

typedef HANDLE             STM_THREAD_TYPE;
typedef HANDLE             STM_MUTEX_TYPE;
typedef struct _STM_SIGNAL STM_SIGNAL_TYPE;

#else

typedef pthread_t          STM_THREAD_TYPE;
typedef pthread_mutex_t    STM_MUTEX_TYPE;
typedef pthread_cond_t     STM_SIGNAL_TYPE;
typedef unsigned long      DWORD;

#endif


uint32_t STM_EXPORT GetProcessorCount(void);


class STM_EXPORT Mutex
{
    friend class Condition;
public:
    Mutex();
    ~Mutex();

    void Lock(void);
    bool TryLock(void);
    void Unlock(void);
protected:
    STM_MUTEX_TYPE &GetMutex(void) {return m_mutex;}
private:
    STM_MUTEX_TYPE m_mutex;
};


class STM_EXPORT Condition
{
public:
    Condition();
    ~Condition();

    void Wait(Mutex &);
    void TimedWait(Mutex &, uint32_t ms);
    void Signal(void);
    void Broadcast(void);
private:
    STM_SIGNAL_TYPE m_cond;
};


template<class T>
class Fifo
{
public:
    Fifo()
    {
    }
    ~Fifo()
    {
    }

    size_t Push(T *item)
    {
        size_t result(0);

        m_lock.Lock();

        if(item)
        {
            m_queue.push(item);
        }
        result = m_queue.size();
        m_signal.Signal();
        m_lock.Unlock();

        return result;
    }

    void Ping(void)
    {
        m_signal.Broadcast();
    }

    T *Pop(void)
    {
        T *result = NULL;

        m_lock.Lock();

        if(m_queue.size())
        {
            result = m_queue.front();
            m_queue.pop();
        }
        else
        {
            m_signal.Wait(m_lock);

            if(m_queue.size())
            {
                result = m_queue.front();
                m_queue.pop();
            }
        }

        m_lock.Unlock();

        return result;
    }

    T *Peek(void)
    {
        T *result = NULL;
        m_lock.Lock();
        if(m_queue.size())
        {
            result = m_queue.front();
        }
        m_lock.Unlock();
    
        return result;
    }
    
private:
    std::queue<T *> m_queue;
    Mutex m_lock;
    Condition m_signal;
};


class STM_EXPORT Lockable
{
    friend class Lock;
public:
    Lockable();
    virtual ~Lockable();
protected:
    class Lock
    {
    public:
        Lock(Lockable *obj);
        ~Lock();
    private:
        Lockable *m_obj;
    };

    Mutex &GetLock() {return m_lock;}
private:
    Mutex m_lock;
};


class STM_EXPORT Thread : public Lockable
{
public:
    Thread()
        : Lockable()
    {};
    virtual ~Thread() {};

    void Start(void);

    void Join(void);

    STM_THREAD_TYPE GetThread(void) const {return m_thread;}
protected:
    virtual void *MainLoop(void) = 0;
private:
    static void *Entry(void *);
    static DWORD WinEntry(void *);

    STM_THREAD_TYPE m_thread;
};

}

#endif

---