ThreadPool.h

Go to the documentation of this file.

#ifndef __THREADPOOL_H
#define __THREADPOOL_H

#include <boost/thread/thread.hpp>

#include "CodeGenMacros.h"

const size_t DefaultMaxThreadsInThreadPool = 25;
const size_t DefaultTaskCountThresholdForNewThread = 5;
const boost::xtime::xtime_sec_t ManagerWaitTimeInSeconds = 1;
const boost::xtime::xtime_sec_t WorkerActiveWaitTimeInSeconds = 0;
const boost::xtime::xtime_sec_t WorkerIdleWaitTimeInSeconds = 1;

namespace Support
{
    class ThreadTaskBase
    {
    public:
        virtual void execute() = 0;
    };

    class ThreadPoolTaskBase : public ThreadTaskBase
    {
    protected:
        bool _deleteOnCompletion;

    public:
        ThreadPoolTaskBase() : _deleteOnCompletion(true) { }

        //Gets or sets whether or not this task should be deleted by the pool after execution
        //Default value is TRUE
        INLINE GET(getDelete, bool, _deleteOnCompletion);
        INLINE SET(setDelete, bool, _deleteOnCompletion);
    };

    class ThreadPool : boost::noncopyable
    {
    protected:
        struct ThreadPoolWorker
        {
            ThreadPool& _threadPool;
            boost::xtime _waitTimeActive;
            boost::xtime _waitTimeIdle;
            
            ThreadPoolWorker(ThreadPool& threadPool);

            void operator()();
        };

        struct ThreadPoolManager
        {
            ThreadPool& _threadPool;
            boost::xtime _waitTime;

            ThreadPoolManager(ThreadPool& threadPool) : _threadPool(threadPool) 
            {
                _waitTime.sec = ManagerWaitTimeInSeconds;
            }

            void operator()();
        };

        mutable boost::mutex _taskMutex;

        std::list<ThreadPoolTaskBase*> _tasks;

        boost::thread_group _threads;

        size_t _maxThreadCount;
        size_t _newThreadThreshold;

        bool SafeDequeue(ThreadPoolTaskBase** item);

        virtual void createWorkerThread();
        virtual void createManagerThread();

        void checkGrowPool();
        bool consumeTask();
        void stop();

    public:

        //max threads is also +1 to accomodate a manager thread that is created to spawn other threads
        ThreadPool();
        ThreadPool(size_t threadCount);
        ThreadPool(size_t maxThreads, size_t growThreshold);

        virtual ~ThreadPool();

        void queueTask(ThreadPoolTaskBase* task);

        size_t taskCount();

        void clearTasks();
    };
}

#endif