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
        {
                
        private:
                ibrcommon::Mutex _cancelLock;
                bool _cancel;
        
        protected:
                pthread_t tid;
                size_t stack;
                int priority;
                pthread_attr_t attr;

                ibrcommon::Conditional _readycond;
                bool _ready;

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

        public:
                const bool __delete_on_exit;

                static void yield(void);

                static void sleep(size_t timeout);

                virtual void run(void) = 0;

                virtual void finally(void) { };

                virtual ~Thread();

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

                void waitready();

                static int enableCancel(int &state);
                static int disableCancel(int &state);
                static int restoreCancel(const int &state);

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

                private:
                        int _oldstate;
                };

                static void testcancel();

                int kill(int sig);

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

                // This sets the cancelation ability of the thread
                int setCancel(bool val);

                static bool equal(pthread_t thread1, pthread_t thread2);

                static void* exec_thread(void *obj);
        };

        class JoinableThread : protected Thread
        {
        private:
                ibrcommon::Mutex running_mutex;
                ibrcommon::Mutex join_mutex;
                volatile bool running;
                volatile bool joined;

        protected:
                JoinableThread(size_t size = DEFAULT_STACKSIZE);

        public:
                virtual ~JoinableThread();

                void join(void);

                inline bool isRunning(void)
                        {return running;};

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

                void stop() throw (ThreadException);

                inline void background(void)
                        {start(-1);};
        };

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

        public:
                virtual ~DetachedThread();

                void exit(void);

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

                void stop() throw (ThreadException);
        };

        class ThreadFinalizer
        {
        public:
                ThreadFinalizer(Thread *t);
                ~ThreadFinalizer();

        private:
                Thread *_thread;
        };
}

#endif /* THREAD_H_ */