ThreadPool und SuspendThread design

[FBIagent]

Guten Tag,

ich baue mir im Momment einen ThreadPool zusammen. Diesem kann ich Threads
anhängen die auf die ThreadPool Threads verteilt werden. Damit ein ThreadPool Thread
nicht immer wieder in seiner Schleife überprüfen muss ob er einen Thread
zugewisen bekommen hat, wollte ich hier mit SuspendThread() und ResumeThread()
arbeiten.

ThreadPoolWorker.h

#ifndef __UTILS_WINAPI_PARALLELISM_THREADPOOLWORKER_H__
#define __UTILS_WINAPI_PARALLELISM_THREADPOOLWORKER_H__

#include ".\Thread.h"
#include ".\ThreadPool.h"

namespace Utils {
    namespace WinAPI {
        namespace Parallelism {

            class ThreadPoolWorker
            : public Thread {
                friend class ThreadPool;

            public:
                ThreadPoolWorker();
                virtual ~ThreadPoolWorker();
            protected:
                void Run();
            private:
                Thread *m_p_Thread;
                bool Usable;

                bool Use( Thread *pThread );
            };

        } // namespace Parallelism
    } // namespace WinAPI
} // namespace Utils

#endif

ThreadPoolWorker.cpp

#include ".\ThreadPoolWorker.h"


namespace Utils {
	namespace WinAPI {
		namespace Parallelism {
			////////////////
			// Public
			ThreadPoolWorker::ThreadPoolWorker()
			: Thread(), Usable( true ), m_p_Thread( NULL ) {
			}

			ThreadPoolWorker::~ThreadPoolWorker() {
			}

			////////////////
			// Protected
			void ThreadPoolWorker::Run() {
				// TODO: Add notify stop support
				while ( true ) {
					if ( m_p_Thread != NULL ) {
						m_p_Thread->Run();
					}

					// TODO: Lock Use mutex
					Usable = true;
					// TODO: Unlock Use mutex
					::SuspendThread( Handle() );
				}
			}

			////////////////
			// Private
			bool ThreadPoolWorker::Use( Thread *pThread ) {
				// TODO: Lock Use mutex
				if ( !Usable ) {
					// TODO: Unlock Use mutex
					return false;
				}

				m_p_Thread = pThread;
				Usable = false;
				::ResumeThread( Handle() );
				// TODO: Unlock Use mutex
				return true;
			}

		} // namespace Parallelism
	} // namespace WinAPI
} // namespace Utils

Nun ist hierbei das Problem, dass bei Zeile 28 SuspendThread(), wenn ich es in den
Use Lock reinpacke, dieser auch nicht mehr freigegeben und dadurch ein Deadlock
entsteht. Wenn ich es wie jetzt nach dem freigeben des Use Lock lasse gibt es die
möglichkeit, das ResumeThread() in Zeile 43 in ThredPoolWorker::Use() vor dem
SuspendThread() ausgeführt würde.

Hat jemand eine Idee was ich da machen könnte?

Best wishes
FBIagent