devel/libmdw/trunk/libmdw/src/ThreadStatic.h

#ifndef __JBMW_THREAD_H_
#define __JBMW_THREAD_H_

#include <pthread.h>

namespace mdw
{
class ThreadStatic
{
public:
    typedef pthread_t thread_t;
    typedef pthread_attr_t thread_attr_t;
    typedef pthread_mutex_t mutex_t;
    typedef pthread_mutexattr_t mutex_attr_t;
    typedef pthread_cond_t cond_t;
    typedef pthread_condattr_t cond_attr_t;
    typedef pthread_key_t key_t;
    typedef pthread_rwlock_t rwlock_t;
    typedef pthread_rwlockattr_t rwlock_attr_t;

    static thread_attr_t our_default_thread_attr;
    static mutex_attr_t our_default_mutex_attr;
    static cond_attr_t our_default_cond_attr;
    static rwlock_attr_t our_default_rwlock_attr;

    class Guard
    {
    public:
        Guard (mutex_t &);
        ~Guard();
    private:
        mutex_t &myMutex;
    };

    class GuardRead
    {
    public:
        GuardRead (rwlock_t &);
        ~GuardRead();
    private:
        rwlock_t &myLock;
    };

    class GuardWrite
    {
    public:
        GuardWrite (rwlock_t &);
        ~GuardWrite();
    private:
        rwlock_t &myLock;
    };

    typedef enum
    {
        Detached_e = PTHREAD_CREATE_DETACHED,
        Joinable_e = PTHREAD_CREATE_JOINABLE
    } AttachedState_t;

    // Important, must be called before anything else
    static void initialise();

    // Call that function at the end, to dealocate all static stuff
    static void finalize();

    // Thread manipulation functions:

    // create a thread
    static int create (thread_t &thread,
                       void * (*start_routine) (void*),
                       void *arg,
                       thread_attr_t &attr = our_default_thread_attr);

    // terminate current thread
    static void exit (void *);

    // cancel execution of another thread
    static int cancel (thread_t);

    // block current thread until another one terminates
    static int join (thread_t, void **);

    // set the detachstate attribute (whether thread can be joined on termination)
    static int setdetachstate (thread_attr_t &, AttachedState_t);

    // get the detachstate attribute
    static int getdetachstate (const thread_attr_t &, AttachedState_t &);


    // Synchronization functions: for mutexes and condition variables

    // initialize mutex lock
    static int mutex_init (mutex_t &, const mutex_attr_t &attr = our_default_mutex_attr);

    // pthread_mutex_destroy()
    static int mutex_destroy (mutex_t &);

    // acquire mutex lock (blocking)
    static int mutex_lock (mutex_t &);

    // acquire mutex lock (non-blocking)
    static int mutex_trylock (mutex_t &);

    // release mutex lock
    static int mutex_unlock (mutex_t &);

    // pthread_cond_init()
    static int cond_init (cond_t &, const cond_attr_t &attr = our_default_cond_attr);

    // pthread_cond_destroy()
    static int cond_destroy (cond_t &);

    // signal a condition
    static int cond_signal (cond_t &);

    // wait on a condition
    static int cond_wait (cond_t &, mutex_t &);

    // wait on a condition with timeout
    static int cond_timedwait (cond_t &, mutex_t &, const struct timespec &);

    // Thread-local storage (or thread-specific data, in Pthreads nomenclature):

    // creates a key that can later be associated with thread specific data
    static int key_create (key_t &, void (*) (void *));

    // associate a key with thread-specific data
    static int setspecific (key_t, const void *);

    // retrieve the data associated with a key
    static void *getspecific (key_t);

    // destroy the key
    static int key_delete (key_t);


    // Some utility functions useful when working with Pthreads

    // test two threads IDs for equality
    static bool equal (thread_t, thread_t);

    // set thread to release resources
    static int detach (thread_t);

    // find out own thread ID
    static thread_t self();

    // Read/Write locks

    // Create a RW lock
    static int rwlock_init (rwlock_t &, const rwlock_attr_t &attr = our_default_rwlock_attr);

    // Destroy a RW lock
    static int rwlock_destroy (rwlock_t &);

    // Get the RW lock in read mode (blocking)
    static int rwlock_rdlock (rwlock_t &);

    // Get the RW lock in read mode (non blocking)
    static int rwlock_tryrdlock (rwlock_t &);

    // Get the RW lock in write mode (blocking)
    static int rwlock_wrlock (rwlock_t &);

    // Get the RW lock in write mode (non blocking)
    static int rwlock_trywrlock (rwlock_t &);

    // Release RW the lock
    static int rwlock_unlock (rwlock_t &);

    // Attribute functions

    // initialize attributes
    static int thread_attr_init (thread_attr_t &);
    static int mutex_attr_init (mutex_attr_t&);
    static int cond_attr_init (cond_attr_t&);
    static int rwlock_attr_init (rwlock_attr_t&);

    // destroy attributes
    static int thread_attr_destroy (thread_attr_t &);
    static int mutex_attr_destroy (mutex_attr_t&);
    static int cond_attr_destroy (cond_attr_t&);
    static int rwlock_attr_destroy (rwlock_attr_t&);

};
}
#endif

---