Thread.h

Go to the documentation of this file.

/*
 * Thread.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#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_CREATED = 1 << 0,
                        THREAD_STARTED = 1 << 1,
                        THREAD_INITIALIZED = 1 << 2,
                        THREAD_RUNNING = 1 << 3,
                        THREAD_CANCELLED = 1 << 4,
                        THREAD_FINALIZING = 1 << 5,
                        THREAD_JOINABLE = 1 << 6,
                        THREAD_FINALIZED = 1 << 7
                };

                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 is detached
                bool _detached;

                Thread(size_t stack = DEFAULT_STACKSIZE);

        public:
                static size_t getNumberOfProcessors();

                virtual ~Thread() = 0;

                void reset() throw (ThreadException);

                static void yield(void);

                static void sleep(time_t timeout);

                virtual void setup(void) throw ()  { };

                virtual void run(void) throw () = 0;

                virtual void finally(void) throw () { };

                static void concurrency(int level);

                bool isFinalized() throw ();

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

        protected:
                int kill(int sig);

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

                static bool equal(pthread_t thread1, pthread_t thread2);

                static void* __execute__(void *obj) throw ();
        };

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

        public:
                virtual ~JoinableThread() = 0;

                void join(void) throw (ThreadException);

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

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

                void stop() throw ();
        };

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