I think I figured out a better way, which is C++03 compliant using std::enable_shared_from_this. It eliminates the need for std::atomic<bool> m_Quit by using the std::shared_ptr::use_count() instead, which is thread safe.

What do you think?

class ThreadSafeCommunication : public std::enable_shared_from_this<ThreadSafeCommunication>
{
[...]
};

class WorkerThread
{
public:
	WorkerThread(DWORD i)
	{
		spInterface = std::make_shared<ThreadSafeCommunication>(i);
		hThread = CreateThread(NULL, 0, WorkerThread::ThreadRoutine, spInterface.get(), NULL, NULL);
	}

	~WorkerThread(void)
	{
		if(hThread)
		{
			CloseHandle(hThread);
		}
	}

private:
	std::shared_ptr<ThreadSafeCommunication> spInterface;
	
	//Thread system
	HANDLE hThread;
	static DWORD WINAPI ThreadRoutine(LPVOID param)
	{
		std::shared_ptr<ThreadSafeCommunication> spInterface = static_cast<ThreadSafeCommunication*>(param)->shared_from_this();
		
		while(spInterface.use_count() == 2)		//Only 2 strong references, one from main and one from thread.
		{
			spInterface->TickThread();

			//do stuff
		}

		return 0;
	}
};

I'm not sure what you mean, std::shared_ptr is itself part of C++11. Is C++11 not an option for you? Personally, I'd prefer to use the portable standard library over system specific code where possible.

Sorry, I mixed up tr1 and c++03. Visual Studio 2010 implements tr1, not c++11.

You've reintroduced the race condition I was trying to address earlier.

Where is the race condition? will WorkerThread( const WorkerThread& ); fix it?

I see. I suppose this will also work?

	static DWORD WINAPI ThreadRoutine(LPVOID lpParam)
	{
		std::shared_ptr<ThreadSafeCommunication> spInterface = static_cast<ThreadSafeCommunication*>(lpParam)->self;
		static_cast<ThreadSafeCommunication*>(lpParam)->self.reset();

		while(!spInterface.unique())
		{
			spInterface->TickThread();
			//do stuff
		}

		return 0;
	}

I also tried to template the whole thing by swapping out std::shared_ptr<InstructionBase> with T. But all hell breaks loose on me. The linker starts complaining about undefined external. Something about CTRP I think. Because I template a class which is inside another templated class. It is in the ThreadRoutine when the T is passed down I can't T->TickThread();

ThreadSafeCommunication<T>

WorkerThread<T>

Is it possible to template out the std::shared_ptr<InstructionBase> as it stands now?

WorkerThread(DWORD i, LPTHREAD_START_ROUTINE lpStartAddress)
	{
		spInterface = std::make_shared<ThreadSafeCommunication<std::shared_ptr<InstructionBase> > >(i);
		spInterface->self = spInterface;
		hThread = CreateThread(NULL, 0, lpStartAddress, spInterface.get(), NULL, NULL);
	}