2

There are:

one conditional variable "var": values of var can be 0 or 1 only;

one provider thread "thP": when received data from net, set var 1 (available);

one consumer thread "thC": wait() for var. When got var, set it 0 (unavailable), and process something afterwards.

.

I found two ways to implement this simple model:

(1) Use pthread_cond_t as var. This method needs an additional mutex and a callback function to unlock mutex while thread will be cleaned.

(2) Use sem_t as var. This method may cause a situation as "var>1". thC may do more than one wait() operations to decrease the var's value to 1.

.

Question is:

To implement this simple model "single provider, single consumer, one conditional variable", which type should I use for var, pthread_cond_t, sem_t or simply using pthread_mutex_t as a binary semaphore?

.

Thanks very much!

Segment Fault
  • 23
  • 3

1 Answers1

1

For a single consumer, single provider, bounded queue example, the typical was to do this is with one lock protecting two conditional variables (one signalled when 'queue is not full' and one signalled when 'queue is not empty').

The algorithm looks like this:

post(item):
  lock;
  while (queue is full):
    wait(cvar_queue_not_full);
  queue.push(item)
  signal(cvar_queue_not_empty);
  unlock;

consume():
  lock;
  while (queue is empty):
    wait(cvar_queue_not_empty);
  item = queue.shift(item);
  signal(cvar_queue_not_full);
  unlock;
  return item;

This is essentially a bounded semaphore, but allows you to atomically adjust the semaphore and push/pop the queue at the same time. Unfortunately POSIX semaphores are unbounded and do not offer atomicity.

bdonlan
  • 224,562
  • 31
  • 268
  • 324
  • A semaphore that does not offer atomicity? That is not a semaphore! – Martin James Apr 26 '12 at 19:35
  • @MartinJames, The semaphore itself is atomic. However you cannot make both adding to a queue and posting to a posix semaphore atomic _together_ without adding some additional form of locking on top of it. – bdonlan Apr 27 '12 at 06:31
  • Yes - the queue must be thread-safe, so you do need a lock, (or thread-safe lock-free queue), as well as the semaphore. – Martin James Apr 27 '12 at 13:55
  • Thanks for answering. I found a Linux implementation of the above algorithm from: http://stackoverflow.com/questions/7478684/how-to-initialise-a-binary-semaphore-in-c. Program works. Thanks! – Segment Fault Apr 28 '12 at 02:10