Lock and semaphore, what's better method for my case

Question

Hi all,
I'm implementing a classic case: a consumption queue with infinite capacity. That's say I have a queue of infinity capacity, a thread to put objects into the queue, another thread take it out. Pseudo code is smth like below:
void put(Object o) {
put message into the queue
if (consume thread is waiting) {
lock();
signal();
unlock();
void eat() {
if (queue not empty)
take object out;
else
lock;
wait for signal from producer;
wake up and take object out;
unlock;
I don't know if I should use semaphore or Lock interface to get the job done. Do you know which one is better in my case? I'm writing an apps which is very sensitive in latency so basically I want the eater to get the object as soon as possible. Any advices?
Message was edited by:
principles

Answer 1

Blocking queue doesn't work for me as it is too slow.
I don't need to lock the data because one thread
adds too the tail, one thread consumes the head, so
why bother?LinkedBlockingQueue allows concurrent access to the head and tail ie it uses two different locks.
A Lock is a mechanism for mutual exclusion. It generally has a notion of ownership and so the thread that locks must be the thread that unlocks.
A Semaphore is a resource counter. There are no constraints on which thread signals() after await(). It is only a protocol that you establish in your code that allows it to be used for exclusion.
A bounded-buffer generally needs two synchronization aids:
a) an exclusion control to ensure the data structure is not corrupted by concurrent access
b) a coordination control to allow consumers to block when the buffer is empty, or producers to block when the buffer is full.
These two can be combined by using "synchronized" methods and wait/notify. Or by using Lock and associated Condition objects. Or you can use "synchronized" blocks or Lock for exclusion, and handle the coordination using a seperate semaphore (which must use some form of internal synchronization too - but perhaps more efficient.)
If you have a lock-free data structure, such as ConcurrentLinkedQueue then you don't need anything for (a) and so you only need coordination. So try using a Semaphore: put() increments it and take() decrements it.
But the Semaphore still becomes a serialization point in your code.