Boost logo

Boost :

From: Howard Hinnant (hinnant_at_[hidden])
Date: 2005-09-23 21:21:56

On Sep 23, 2005, at 7:43 PM, Jason Hise wrote:

> I am relatively new to threading, so forgive me if my question is
> naive,
> but what is the formal definition of a condition variable? If a
> condition variable is capable of making a thread that has been
> explicitly told to sleep until a certain time wake up early, can you
> show me an example of its use?

On Sep 23, 2005, at 8:52 PM, Peter Petrov wrote:

> Instead of sleeping, use timed_wait on a condition variable. Upon
> awakening, check the cause (which could be timeout, valid signal, or
> spurious wakeup).

<nod> I remember well my first introduction to condition variables.
At first they seemed rather strange. But I view them now as
fundamental as a mutex (from a client's point of view). You just can't
live without them.

I could've sworn boost had a good example or two of condition usage,
but I'm not finding one tonight. So here's a bounded_queue demo I
wrote some time ago. It's a copy/paste from example code and it uses
Metrowerks::condition and such. You can just substitute "boost" for
"Metrowerks" and you ought to be pretty close with it. The basic idea
is that a thread can lock a mutex, then go to sleep on a condition
variable, passing it the locked mutex. The condition variable
atomically unlocks the mutex, allows another thread to make the
condition true (probably needing to lock the mutex), and relocks the
mutex, awaking the original thread. The original thread awakes with
whatever condition it needs magically satisfied (by another thread),
and it's mutex locked and ready to rock & roll (but beware of spurious
wake ups).

There are really few libraries that are worth a full-stop and a
deep-dive learning experience for a day or two. boost::condition is
one of those libraries (or equivalently pthread_cond_init,
pthread_cond_destroy, pthread_cond_signal, pthread_cond_broadcast,
pthread_cond_wait, pthread_cond_timedwait).

#include <iostream>
#include <bind>
#include <cdeque>
#include <msl_thread>

class bounded_queue
     typedef Metrowerks::mutex Mutex;
     typedef Mutex::scoped_lock lock;

     bounded_queue(int max) {the_queue_.reserve((unsigned)max);}

     void send (int m);
     int receive();

     Metrowerks::cdeque<int> the_queue_;
     Metrowerks::condition queue_is_empty_so_;
     Metrowerks::condition queue_is_full_so_;
     Mutex mut_;

template <class C>
struct container_not_full
     container_not_full(const C& c) : c_(c) {}
     bool operator()() const {return c_.size() != c_.capacity();}
     const C& c_;

template <class C>
struct container_not_empty
     container_not_empty(const C& c) : c_(c) {}
     bool operator()() const {return !c_.empty();}
     const C& c_;

bounded_queue::send (int m)
     lock lk(mut_);
container_not_full<Metrowerks::cdeque<int> >(the_queue_));
     std::cout << "sent: " << m << '\n';
     if (the_queue_.size() == 1)

     lock lk(mut_);
container_not_empty<Metrowerks::cdeque<int> >(the_queue_));
     int i = the_queue_.front();
     std::cout << "received: " << i << '\n';
     if (the_queue_.size() == the_queue_.capacity())
     return i;

bounded_queue buf(20);

void sender(volatile bool& cancel)
     int n = 0;
     while (!cancel)

void receiver()
     int n;
         n = buf.receive();
     } while (n >= 0);

int main()
     volatile bool cancel = false;
     Metrowerks::thread send(std::tr1::bind(sender,
     Metrowerks::thread receive(receiver);
     cancel = true;


Boost list run by bdawes at, gregod at, cpdaniel at, john at