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"
#include "ibrcommon/thread/ThreadsafeState.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 = 1 << 0,
                        THREAD_PREPARE = 1 << 1,
                        THREAD_SETUP = 1 << 2,
                        THREAD_RUNNING = 1 << 3,
                        THREAD_CANCELLED = 1 << 4,
                        THREAD_FINALIZING = 1 << 5,
                        THREAD_FINALIZED = 1 << 6,
                        THREAD_JOINED = 1 << 7,
                        THREAD_ERROR = 1 << 8
                };
                
                ibrcommon::ThreadsafeState<THREAD_STATE> _state;

                // 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);
                }

        protected:
                int kill(int sig);

                void cancel() throw (ThreadException);
                virtual void __cancellation() = 0;

                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_ */