class ThreadPool
		{
			// Typedefs
			typedef function<void(void)> ThreadStart;

			// Fields
		private:
			list<thread*> threads;
			queue<ThreadStart> workItems;
			mutex workItemsMutex;
			mutex signalMutex;

			// Constructors / Destructor
		public:
			ThreadPool(int numWorkers)
			{
				signalMutex.lock();
				for (int i = 0; i < numWorkers; ++i)
				{
					thread* thr = new thread(boost::bind(&ThreadPool::RunWorker, this));
					this->threads.push_back(thr);
				}
			}
			~ThreadPool()
			{
				mutex::scoped_lock lock(this->workItemsMutex);
				list<thread*>::iterator it = this->threads.begin();

				while (it != this->threads.end())
				{
					delete *it;
					it = this->threads.erase(it);
				}
			}

			// Methods
		public:
			void QueueWorkItem(const ThreadStart& start)
			{
				// Add the work item to the queue
				mutex::scoped_lock lock(this->workItemsMutex);
				this->workItems.push(start);

				// Unlock the work item signal
				signalMutex.unlock();
			}

		private:
			void RunWorker()
			{
				while (true)
				{
					// Wait for the signal from QueueWorkItem
					signalMutex.lock();
					signalMutex.unlock();

					// Attempt to grab a work item from the list
					ThreadStart workItem;
					bool hasWorkItem = false;
					{
						mutex::scoped_lock lock(this->workItemsMutex);
						if (!this->workItems.empty())
						{
							workItem = this->workItems.front();
							this->workItems.pop();
							hasWorkItem = true;
						}
						
						// If the work item list is now empty, lock the signal
						if (this->workItems.empty())
							signalMutex.lock();
					}

					// Run the work item in the context of this thread
					if (hasWorkItem)
						workItem();
				}
			}
		};#