ibrcommon/ibrcommon/thread/Thread.h

Go to the documentation of this file.

/*
 * Thread.h
 *
 *  Created on: 30.07.2009
 *      Author: morgenro
 */

#ifndef IBRCOMMON_THREAD_H_
#define IBRCOMMON_THREAD_H_

#include <pthread.h>
#include <sys/types.h>
#include "ibrcommon/thread/Mutex.h"
#include "ibrcommon/thread/Conditional.h"

//2 MB is a sensible default, we set this since system defaults vary widely: https://computing.llnl.gov/tutorials/pthreads/#Stack
#define DEFAULT_STACKSIZE 2*1024*1024

namespace ibrcommon
{
        class ThreadException : public ibrcommon::Exception
        {
        public:
                ThreadException(int err = 0, string what = "An error occured during a thread operation.") throw() : ibrcommon::Exception(what), error(err)
                {
                };

                const int error;
        };

        class Thread
        {
        protected:
                enum THREAD_STATE
                {
                        THREAD_INITIALIZED,
                        THREAD_PREPARE,
                        THREAD_RUNNING,
                        THREAD_CANCELLED,
                        THREAD_FINALIZED,
                        THREAD_JOINED,
                        THREAD_ERROR
                } _state;
                
                ibrcommon::Conditional _state_lock;

                // thread's id
                pthread_t tid;

                // thread's stack size
                size_t stack;

                // thread's priority
                int priority;

                // thread's attributes
                pthread_attr_t attr;

                Thread(size_t stack = DEFAULT_STACKSIZE, bool delete_on_exit = false);

        public:
                virtual ~Thread() = 0;

                static void yield(void);

                static void sleep(size_t timeout);

                virtual void setup(void) { };

                virtual void run(void) = 0;

                virtual void finally(void) { };

                static void exit(void);

                void detach(void);

                static void concurrency(int level);

                bool operator==(const ibrcommon::Thread &other)
                {
                        return (equal(other.tid, tid) != 0);
                }

                void interrupt();

        protected:
                class CancelProtector
                {
                public:
                        CancelProtector(bool enable = false);
                        virtual ~CancelProtector();

                private:
                        int _oldstate;
                };

                int kill(int sig);

                void cancellation_point();

                void enable_interruption();

                void disable_interruption();

                void cancel() throw (ThreadException);
                virtual bool __cancellation() { return false; };

                static bool equal(pthread_t thread1, pthread_t thread2);

                static void* exec_thread(void *obj);

                static void finalize_thread(void *obj);

        private:
                const bool __delete_on_exit;

                sigset_t mask, orig_mask;
        };

        class JoinableThread : protected Thread
        {
        protected:
                JoinableThread(size_t size = DEFAULT_STACKSIZE);

        public:
                virtual ~JoinableThread() = 0;

                void join(void);

                inline bool isRunning(void)
                        { return _state == THREAD_RUNNING; };

                void start(int priority = 0) throw (ThreadException);

                void stop() throw (ThreadException);
        };

        class DetachedThread : protected Thread
        {
        protected:
                DetachedThread(size_t size = DEFAULT_STACKSIZE);

        public:
                virtual ~DetachedThread() = 0;

                void start(int priority = 0) throw (ThreadException);

                void stop() throw (ThreadException);
        };
}

#endif /* THREAD_H_ */