commoncpp/thread.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef COMMONCPP_THREAD_H_
#define COMMONCPP_THREAD_H_

#ifndef COMMONCPP_CONFIG_H_
#include <commoncpp/config.h>
#endif

#ifndef COMMONCPP_STRING_H_
#include <commoncpp/string.h>
#endif

#define ENTER_CRITICAL  enterMutex();
#define LEAVE_CRITICAL  leaveMutex();

NAMESPACE_COMMONCPP

class __EXPORT Mutex : protected ucommon::RecursiveMutex
{
public:
    inline Mutex() : RecursiveMutex() {};

    inline void enterMutex(void)
        {RecursiveMutex::lock();};

    inline void leaveMutex(void)
        {RecursiveMutex::release();};

    inline bool tryEnterMutex(void)
        {return RecursiveMutex::lock(0l);};

    inline void enter(void)
        {RecursiveMutex::lock();};

    inline void leave(void)
        {RecursiveMutex::release();};

    inline bool test(void)
        {return RecursiveMutex::lock(0l);};

};

class __EXPORT MutexCounter : public Mutex
{
protected:
    volatile int    counter;

public:
    MutexCounter();

    MutexCounter(int initial);

    int operator++();
    int operator--();
};

class __EXPORT MutexLock
{
private:
    Mutex& mutex;

public:
    inline MutexLock( Mutex& _mutex ) : mutex( _mutex )
        { mutex.enterMutex(); }

    // this should be not-virtual
    inline ~MutexLock()
        { mutex.leaveMutex(); }
};

class __EXPORT ThreadLock : protected ucommon::ThreadLock
{
public:
    inline ThreadLock() : ucommon::ThreadLock() {};

    inline void readLock(void)
        {ucommon::ThreadLock::access();};

    inline void writeLock(void)
        {ucommon::ThreadLock::modify();};

    inline void tryReadLock(void)
        {ucommon::ThreadLock::access(0);};

    inline void tryWriteLock(void)
        {ucommon::ThreadLock::modify(0);};

    inline void unlock(void)
        {ucommon::ThreadLock::release();};
};

class __EXPORT ReadLock
{
private:
    ThreadLock& tl;

public:
    inline ReadLock( ThreadLock& _tl ) : tl( _tl )
        { tl.readLock(); }
    // this should be not-virtual
    inline ~ReadLock()
        { tl.unlock(); }
};

class __EXPORT WriteLock
{
private:
    ThreadLock& tl;

public:
    inline WriteLock( ThreadLock& _tl ) : tl( _tl )
        { tl.writeLock(); }
    // this should be not-virtual
    inline ~WriteLock()
        { tl.unlock(); }
};

class __EXPORT Conditional : private ucommon::Conditional
{
public:
    inline Conditional() : ucommon::Conditional() {};

    bool wait(timeout_t timeout, bool locked = false);

    void signal(bool broadcast);

    inline void enterMutex(void)
        {ucommon::Conditional::lock();}

    inline void leaveMutex(void)
        {ucommon::Conditional::unlock();}
};

class __EXPORT Semaphore : private ucommon::Semaphore
{
public:
    inline Semaphore(unsigned size = 0) : ucommon::Semaphore(size) {};

    inline bool wait(timeout_t timeout)
        {return ucommon::Semaphore::wait(timeout);}

    inline void wait(void)
        {ucommon::Semaphore::wait();}

    inline void post(void)
        {ucommon::Semaphore::release();}
};

class __EXPORT SemaphoreLock
{
private:
    Semaphore& sem;

public:
    inline SemaphoreLock( Semaphore& _sem ) : sem( _sem )
        { sem.wait(); }
    // this should be not-virtual
    inline ~SemaphoreLock()
        { sem.post(); }
};

class __EXPORT Event : private ucommon::TimedEvent
{
public:
    inline Event() : ucommon::TimedEvent() {};

    inline void wait(void)
        {ucommon::TimedEvent::wait();}

    inline bool wait(timeout_t timeout)
        {return ucommon::TimedEvent::wait(timeout);}

    inline void signal(void)
        {ucommon::TimedEvent::signal();}

    inline void reset(void)
        {ucommon::TimedEvent::reset();}

    inline void set(timeout_t timeout = 0)
        {ucommon::TimedEvent::set(timeout);}
};

class __EXPORT Thread : protected ucommon::JoinableThread
{
public:
    typedef enum Throw {
        throwNothing,  
        throwObject,   
        throwException 
    } Throw;

private:
    friend class Slog;

    Throw exceptions;
    bool detached, terminated;
    Thread *parent;
    size_t msgpos;
    char msgbuf[128];

public:
    Thread(int pri = 0, size_t stack = 0);

    virtual ~Thread();

    inline void map(void)
        {JoinableThread::map();};

    virtual void initial(void);
    virtual void notify(Thread *thread);
    virtual void final(void);
    virtual void run(void) = 0;

    void terminate(void);
    void finalize(void);

    void detach(void);
    void start(void);
    void exit(void);

    inline void join(void)
        {JoinableThread::join();};

    inline void sync(void)
        {Thread::exit();};

    static inline Thread *get(void)
        {return (Thread *)JoinableThread::get();};

    inline static void yield(void)
        {ucommon::Thread::yield();};

    inline static void sleep(timeout_t msec = TIMEOUT_INF)
        {ucommon::Thread::sleep(msec);};

    bool isRunning(void);

    bool isThread(void);

    static Throw getException(void);

    static void setException(Throw mode);

    inline pthread_t getId(void)
        {return tid;};
};

class __EXPORT SysTime
{
public:
    static time_t getTime(time_t *tloc = NULL);
    static time_t time(time_t *tloc)
        { return getTime(tloc); };

    static int getTimeOfDay(struct timeval *tp);
    static int gettimeofday(struct timeval *tp, struct timezone *)
        { return getTimeOfDay(tp); };

    static struct tm *getLocalTime(const time_t *clock, struct tm *result);
    static struct tm *locatime(const time_t *clock, struct tm *result)
        { return getLocalTime(clock, result); };

    static struct tm *getGMTTime(const time_t *clock, struct tm *result);
    static struct tm *gmtime(const time_t *clock, struct tm *result)
        { return getGMTTime(clock, result);};
};

class __EXPORT TimerPort
{
#ifndef _MSWINDOWS_
    struct timeval timer;
#else
    DWORD timer;
#endif
    bool active;

public:
    TimerPort();

    void setTimer(timeout_t timeout = 0);

    void incTimer(timeout_t timeout);

    void decTimer(timeout_t timeout);

    void sleepTimer(void);

    void endTimer(void);

    timeout_t getTimer(void) const;

    timeout_t getElapsed(void) const;
};

#ifndef _MSWINDOWS_
struct  timespec *getTimeout(struct timespec *spec, timeout_t timeout);
#endif

inline struct tm *localtime_r(const time_t *t, struct tm *b)
    {return SysTime::getLocalTime(t, b);}

inline char *ctime_r(const time_t *t, char *buf)
    {return ctime(t);}

inline struct tm *gmtime_r(const time_t *t, struct tm *b)
    {return SysTime::getGMTTime(t, b);}

inline char *asctime_r(const struct tm *tm, char *b)
    {return asctime(tm);}

inline Thread *getThread(void)
    {return Thread::get();}

#ifdef  _MSWINDOWS_
class __EXPORT Buffer : public Mutex
#else
class __EXPORT Buffer : public Conditional
#endif
{
private:
#ifdef  _MSWINDOWS_
    HANDLE  sem_head, sem_tail;
#endif
    size_t _size;
    size_t _used;

protected:
    virtual size_t onPeek(void *buf) = 0;

    virtual size_t onWait(void *buf) = 0;

    virtual size_t onPost(void *buf) = 0;

public:
    static const size_t timeout;

    Buffer(size_t capacity);
    virtual ~Buffer();

    inline size_t getSize(void)
        {return _size;};

    inline size_t getUsed(void)
        {return _used;};

    size_t wait(void *buf, timeout_t timeout = 0);

    size_t post(void *buf, timeout_t timeout = 0);

    size_t peek(void *buf);

    virtual bool isValid(void);
};

class __EXPORT FixedBuffer : public Buffer
{
private:
    char *buf, *head, *tail;
    size_t objsize;

protected:
    size_t onPeek(void *buf);

    size_t onWait(void *buf);

    size_t onPost(void *buf);

public:
    FixedBuffer(size_t capacity, size_t objsize);

    FixedBuffer(const FixedBuffer &fb);

    virtual ~FixedBuffer();

    FixedBuffer &operator=(const FixedBuffer &fb);

    bool isValid(void);
};

class __EXPORT ThreadQueue : public Mutex, public Thread, public Semaphore
{
private:
    void run(void);         // private run method

protected:
    typedef struct _data {
        struct _data *next;
        unsigned len;
        char data[1];
    }   data_t;

    timeout_t timeout;
    bool started;

    data_t *first, *last;       // head/tail of list

    String name;

    /*
     * Overloading of final(). It demarks Semaphore to avoid deadlock.
     */
    virtual void final();

    virtual void startQueue(void);

    virtual void stopQueue(void);

    virtual void onTimer(void);

    virtual void runQueue(void *data) = 0;

public:
    ThreadQueue(const char *id, int pri, size_t stack = 0);

    virtual ~ThreadQueue();

    void setTimer(timeout_t timeout);

    void post(const void *data, unsigned len);
};


inline size_t get(Buffer &b, void *o, timeout_t t = 0)
    {return b.wait(o, t);}

inline size_t put(Buffer &b, void *o, timeout_t t = 0)
    {return b.post(o, t);}

inline size_t peek(Buffer &b, void *o)
    {return b.peek(o);}

END_NAMESPACE

#endif

---