Threads.hpp

Idź do dokumentacji tego pliku.

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#ifndef COMMON_THREADS_H_
#define COMMON_THREADS_H_

namespace common
{


class Thread_pimpl;
class Mutex_pimpl;
class Semaphore_pimpl;
class Cond_pimpl;
class Barrier_pimpl;
class Event_pimpl;


class Thread
{
        DECLARE_NO_COPY_CLASS(Thread)
        friend class Thread_pimpl;

private:
        scoped_ptr<Thread_pimpl> pimpl;
        
protected:
        virtual void Run() = 0;


        void Exit();

        void Yield_();

public:
        Thread();
        virtual ~Thread();

        void Start();

        void Join();

        void Kill();

// Rzeczy które nie wiem jak zrealizować w pthreads - działają tylko w Windows
#ifdef WIN32
        bool IsRunning();

        void Pause();
        void Resume();

        static const int PRIORITY_IDLE;
        static const int PRIORITY_VERY_LOW;
        static const int PRIORITY_LOW;
        static const int PRIORITY_DEFAULT;
        static const int PRIORITY_HIGH;
        static const int PRIORITY_VERY_HIGH;
        static const int PRIORITY_REALTIME;
        void SetPriority(int Priority);
        int GetPriority();
#endif
};


class Mutex
{
        DECLARE_NO_COPY_CLASS(Mutex)
        friend class Mutex_pimpl;
        friend class Cond;

private:
        scoped_ptr<Mutex_pimpl> pimpl;

public:

        static const uint FLAG_RECURSIVE    = 0x01;
        static const uint FLAG_WAIT_TIMEOUT = 0x02;

        Mutex(uint Flag);
        ~Mutex();

        void Lock();
        void Unlock();

        bool TryLock();

        bool TimeoutLock(uint Milliseconds);
};


class MutexLock
{
private:
        Mutex *m_Mutex;
        DECLARE_NO_COPY_CLASS(MutexLock)

public:
        MutexLock(Mutex *m) : m_Mutex(m) { m->Lock(); }
        ~MutexLock() { m_Mutex->Unlock(); }
};

#define MUTEX_LOCK(M) MutexLock __mutex_lock_obj(M);


class Semaphore
{
        DECLARE_NO_COPY_CLASS(Semaphore)

private:
        scoped_ptr<Semaphore_pimpl> pimpl;

public:
        Semaphore(uint InitialValue);
        ~Semaphore();


        void P();

        bool TryP();

        bool TimeoutP(uint Milliseconds);

        void V();
        void V(uint ReleaseCount);
};


class Cond
{
        DECLARE_NO_COPY_CLASS(Cond)

private:
        scoped_ptr<Cond_pimpl> pimpl;

public:
        Cond();
        ~Cond();


        void Wait(Mutex *m);

        bool TimeoutWait(Mutex *m, uint Milliseconds);


        void Signal();

        void Broadcast();
};


class Barrier
{
        DECLARE_NO_COPY_CLASS(Barrier)

private:
        scoped_ptr<Barrier_pimpl> pimpl;

public:
        Barrier(uint NumThreads);
        ~Barrier();

        void Wait();
};


class Event
{
        DECLARE_NO_COPY_CLASS(Event);

private:
        scoped_ptr<Event_pimpl> pimpl;

public:
        enum TYPE
        {
                TYPE_AUTO_RESET,
                TYPE_MANUAL_RESET,
        };

        Event(bool InitialState, TYPE Type);
        ~Event();


        void Set();
        void Reset();


        void Wait();

        bool Test();

        bool TimeoutWait(uint Milliseconds);
};

// code_threads

} // namespace common

#endif

---