Threads.hpp

Go to the documentation of this file.

#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
  uint GetNativeHandle(); 
  uint GetNativeId(); 

  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();

  void SetThreadName(const char *s);
  static void SetThreadNameById(uint threadId, const char *s);
  static void SetMainThreadName(const char *s);
#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) common::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);
};

class RWLock
{
  DECLARE_NO_COPY_CLASS(RWLock)

public:
  RWLock() : m_Readers(0), m_ReadersEvent(true, Event::TYPE_AUTO_RESET), m_DataEvent(true, Event::TYPE_AUTO_RESET) { }

  void LockWrite() { m_DataEvent.Wait(); }
  bool TryLockWrite() { return m_DataEvent.Test(); }
  bool TimeoutLockWrite(uint Milliseconds) { return m_DataEvent.TimeoutWait(Milliseconds); }
  void UnlockWrite() { m_DataEvent.Set(); }

  void LockRead()
  {
    m_ReadersEvent.Wait();
    if (m_Readers++ == 0) m_DataEvent.Wait();
    m_ReadersEvent.Set();
  }
  void UnlockRead()
  {
    m_ReadersEvent.Wait();
    if (--m_Readers == 0) m_DataEvent.Set();
    m_ReadersEvent.Set();
  }

private:
  int m_Readers;
  Event m_ReadersEvent, m_DataEvent;
};

class ReadLock
{
  DECLARE_NO_COPY_CLASS(ReadLock)
public:
  ReadLock(RWLock &lock) : m_Lock(lock) { lock.LockRead(); }
  ~ReadLock() { m_Lock.UnlockRead(); }
private:
  RWLock &m_Lock;
};

class WriteLock
{
  DECLARE_NO_COPY_CLASS(WriteLock)
public:
  WriteLock(RWLock &lock) : m_Lock(lock) { lock.LockWrite(); }
  ~WriteLock() { m_Lock.UnlockWrite(); }
private:
  RWLock &m_Lock;
};

// code_threads

} // namespace common

#endif

---