The Object's monitor is used to synchronize the methods in here.
If you are using a semaphore to signal, you can call this once for each count of it and you can do that separately from this call (though they should be paired).
Note that if you use a semaphore to signal waiting threads, you should probably not call this.
If this returns true, you should signal listening threads (with an event or a semaphore, depending on how you dequeue it). If it returns false, the queue was full and your thing was NOT added. You might wait and retry later (you could set up another event to signal it has been read and wait for that, or maybe try on a timer), or just fail and throw an exception or to abandon the message.
Note the potential race condition between calling this and actually dequeuing something. You might want to acquire the lock on the object before calling this (nested synchronized things are allowed as long as the same thread is the one doing it).
Note the potential race condition between calling this and actually queuing something.
This is primarily a helper for the event queues. It is public in the hope it might be useful, but subject to change without notice; I will treat breaking it the same as if it is private. (That said, it is a simple little utility that does its job, so it is unlikely to change much. The biggest change would probably be letting it grow and changing from inline to dynamic array.)
It is a fixed-size ring buffer that synchronizes on a given object you give it in the constructor.
After enqueuing something, you should probably set an event to notify the other threads. This is left as an exercise to you (or another wrapper).