I have need of a semaphore, but I have been unable to find any good ones on the web, only some source.
So I modified the source to roll out my own simplistic semaphore, and thus I'd like for some other people to look it over and see that I haven't done something stupid.
If you know of a good (and fast!) semaphore out there already, I'd also be interested.

Code:
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/mutex.hpp>    
#include <tbb/atomic.h>

class XSemaphore
{
	//The current semaphore count.
	tbb::atomic<unsigned int> m_count;

	//mutex_ protects count_.
	//Any code that reads or writes the count_ data must hold a lock on
	//the mutex.
	boost::mutex m_mutex;

	//Code that increments count_ must notify the condition variable.
	boost::condition_variable m_condition;

public:
	explicit XSemaphore(unsigned int initial_count)
	{
		m_count = initial_count;
	}

	unsigned int get_count() const //for debugging/testing only
	{
		//The "lock" object locks the mutex when it's constructed,
		//and unlocks it when it's destroyed.
		//boost::unique_lock<boost::mutex> lock(mutex_);
		return m_count;
	}

	void signal() //called "release" in Java
	{
		++m_count;

		//Wake up any waiting threads. 
		//Always do this, even if count_ wasn't 0 on entry. 
		//Otherwise, we might not wake up enough waiting threads if we 
		//get a number of signal() calls in a row.
		m_condition.notify_one(); 
	}

	void wait() //called "acquire" in Java
	{
		while (m_count == 0)
		{
			boost::unique_lock<boost::mutex> lock(m_mutex);
			m_condition.wait(lock);
		}
		--m_count;
	}

};