thread.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <thread>
#include <promeki/atomic.h>
#include <promeki/basicthread.h>
#include <promeki/mutex.h>
#include <promeki/objectbase.h>
#include <promeki/set.h>
#include <promeki/waitcondition.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Thread : public ObjectBase {
                PROMEKI_OBJECT(Thread, ObjectBase)
        public:
                using NativeHandle = BasicThread::NativeHandle;
                static Thread *adoptCurrentThread();
 
                static Thread *currentThread();
 
                Thread(ObjectBase *parent = nullptr);
 
                virtual ~Thread();
 
                Error start(size_t stackSize = 0);
 
                Error wait(unsigned int timeoutMs = 0);
 
                EventLoop *threadEventLoop() const;
 
                void quit(int returnCode = 0);
 
                int exitCode() const { return _exitCode.value(); }
 
                bool isRunning() const { return _running.value(); }
 
                bool isAdopted() const { return _adopted; }
 
                bool isCurrentThread() const { return _currentThread == this; }
 
                const BasicThread &basicThread() const { return _basic; }
 
                uint64_t nativeId() const { return _nativeId.value(); }
 
                std::thread::id id() const { return _stdId.value(); }
 
                SchedulePolicy schedulePolicy() const;
 
                int priority() const;
 
                Error setPriority(int priority, SchedulePolicy policy = SchedulePolicy::Default);
 
                String name() const;
 
                void setName(const String &name);
 
                Set<int> affinity() const;
 
                Error setAffinity(const Set<int> &cpus);
 
                PROMEKI_SIGNAL(started);
 
                PROMEKI_SIGNAL(finished, int);
 
        protected:
                virtual void run();
 
        private:
                static thread_local Thread *_currentThread;
 
                BasicThread             _basic;
                Atomic<bool>            _running;
                Atomic<int>             _exitCode;
                Atomic<uint64_t>        _nativeId;
                Atomic<std::thread::id> _stdId;
                String                  _name;
                EventLoop              *_threadLoop = nullptr;
                mutable Mutex           _mutex;
                WaitCondition           _startedCv;
                WaitCondition           _finishedCv;
                bool                    _started = false;
                bool                    _finished = false;
                bool                    _adopted = false;
 
                NativeHandle nativeHandle() const;
                bool         isJoinable() const { return _basic.isJoinable(); }
                void         threadEntry();
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE