Thread.h

Go to the documentation of this file.

//Luke Lenhart (2007)
//See /docs/License.txt for details on how this code may be used.

#pragma once

#include "Types.h"
#include "Locks.h"
#include <list>

namespace MPMA
{
    // -- Thread Class

    enum ThreadPriority
    {
        THREAD_LOW, 
        THREAD_NORMAL, 
        THREAD_HIGH 
    };

    union ThreadParam
    {
        void *ptr;
        int val;

        //handy contructors
        inline ThreadParam(): val(0) 
            {}
        inline ThreadParam(void *somePtr): val(0) 
            { ptr=somePtr; }
        inline ThreadParam(int someInt): ptr(0) 
            { val=someInt; }
        inline ThreadParam(const ThreadParam &p)
            { ptr=p.ptr; val=p.val; }
    };

    typedef void (*ThreadFunc)(class Thread&, ThreadParam);

    class Thread
    {
    public:
        Thread(ThreadFunc proc, ThreadParam param);

        ~Thread();

        void SetPriority(ThreadPriority newPriority);

        bool IsRunning() const;

        bool IsEnding() const;

    protected:
        void SetEnding();

    private:
        //you cannot duplicate a thread
        Thread(const Thread&);
        const Thread& operator=(const Thread&);

        //internal use to store thread state
        void *internal;

        friend class ThreadPool;
    };


    // -- Threadpool class

    class ThreadPool
    {
    public:
        ThreadPool(nuint initialThreads=1, nuint maxThreads=100);
        ~ThreadPool();

        void RunThread(ThreadFunc proc, ThreadParam param);

    private:
        class ThreadPoolThread
        {
        public:
            ThreadPool *pool;
            Thread *thread;
            ThreadFunc runFunc;
            ThreadParam runParam;
            BlockingObject block;
            bool isEnding;
            bool isAssigned;
            bool isReadyToRun;
        };

        void GrowPool();
        ThreadPoolThread* GetThreadFromPool();
        void ReturnThreadToPool(ThreadPoolThread *thread);

        static void ThreadProc(Thread &myThread, ThreadParam param);

        std::list<ThreadPoolThread*> availableThreads;
        std::list<ThreadPoolThread*> allThreads;
        nuint threadLimit;
        nuint threadCount;
        SpinLock listLock;
        BlockingObject threadReturnBlock;

        //you cannot duplicate a threadpool
        ThreadPool(const ThreadPool&);
        const ThreadPool& operator=(const ThreadPool&);
    };


    // -- Thread-related helpers

    void Sleep(nuint time);

    nuint GetThreadUniqueIdentifier();
}