ThreadPool.h

Go to the documentation of this file.

#ifndef OS_WRAPPER_THREAD_POOL_H_INCLUDED
#define OS_WRAPPER_THREAD_POOL_H_INCLUDED
 
#include <cstddef>
#include "Runnable.h"
#include "Thread.h"
#include "Container/PreallocatedVector.h"
 
namespace OSWrapper {
 
template <typename T> class MessageQueue;
class EventFlag;
class FixedMemoryPool;
 
class ThreadPool {
private:
    class TaskRunner : public Runnable {
    public:
        void release();
        Error timedWait(Timeout tmout);
 
    private:
        friend class ThreadPool;
 
        TaskRunner(EventFlag* ev, ThreadPool* tp);
        ~TaskRunner();
        void startThread(Runnable* task, int priority, bool needsWaiting);
        void run();
        void invoke();
        void afterInvoke();
        void notifyFinished();
        void setThread(Thread* t) { m_thread = t; }
        Thread* getThread() const { return m_thread; }
        EventFlag* getEventFlag() const { return m_ev; }
 
        Runnable* m_task;
        Thread* m_thread;
        EventFlag* m_ev;
        bool m_needsWaiting;
        ThreadPool* m_tp;
 
        TaskRunner(const TaskRunner&);
        TaskRunner& operator=(const TaskRunner&);
    };
 
public:
    class WaitGuard {
    public:
        WaitGuard();
 
        ~WaitGuard();
 
        void release();
 
        Error wait();
 
        Error tryWait();
 
        Error timedWait(Timeout tmout);
 
        bool isValid() const;
 
    private:
        friend class ThreadPool;
        TaskRunner* m_runner;
 
        WaitGuard(const WaitGuard&);
        WaitGuard& operator=(const WaitGuard&);
    };
 
    static ThreadPool* create(std::size_t maxThreads, std::size_t stackSize = 0U, int defaultPriority = Thread::getNormalPriority(), const char* threadName = "");
 
    static void destroy(ThreadPool* p);
 
    Error start(Runnable* task, WaitGuard* waiter = 0, int priority = Thread::INHERIT_PRIORITY);
 
    Error tryStart(Runnable* task, WaitGuard* waiter = 0, int priority = Thread::INHERIT_PRIORITY);
 
    Error timedStart(Runnable* task, Timeout tmout, WaitGuard* waiter = 0, int priority = Thread::INHERIT_PRIORITY);
 
    void setUncaughtExceptionHandler(Thread::UncaughtExceptionHandler* handler);
 
    Thread::UncaughtExceptionHandler* getUncaughtExceptionHandler() const;
 
    const char* getThreadName() const;
 
private:
    typedef MessageQueue<TaskRunner*> TaskRunnerMQ;
    TaskRunnerMQ* m_freeRunnerQueue;
 
    typedef Container::PreallocatedVector<Thread*> ThreadVector;
    ThreadVector m_threads;
    void* m_threadMemory;
 
    FixedMemoryPool* m_threadMemoryPool;
    FixedMemoryPool* m_runnerPool;
    FixedMemoryPool* m_objPool;
 
    Thread::UncaughtExceptionHandler* m_uncaughtExceptionHandler;
    const int m_defaultPriority;
    const char* m_threadName;
 
    bool constructMembers(std::size_t maxThreads, std::size_t stackSize);
    void destroyMembers();
    void destroyRunners();
    void destroyThreads();
    void waitThreads();
    void releaseRunner(TaskRunner* runner);
    int getDefaultPriority() const { return m_defaultPriority; }
 
    ThreadPool(FixedMemoryPool* objPool, int defaultPriority, const char* threadName);
    ~ThreadPool();
 
    ThreadPool(const ThreadPool&);
    ThreadPool& operator=(const ThreadPool&);
};
 
}
 
#endif // OS_WRAPPER_THREAD_POOL_H_INCLUDED