boost_condition

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <iostream>
using namespace std;

const int BUF_SIZE = 10;
const int ITERS    = 100;

boost::mutex io_mutex;
typedef boost::mutex::scoped_lock SCOPE_LOCK;

class buffer
{
public:    
    buffer():p(0),c(0),full(0){ }

    void put(int m)
    {
        SCOPE_LOCK lock(mutex);
        if(full == BUF_SIZE)
        {
            {
                SCOPE_LOCK locl(io_mutex);
                cout<<"Buffer is full.Wait..."<<endl;
            }
            while(full == BUF_SIZE)
            {
                cond.wait(lock);
            }
        }
        buf[p] = m;
        p = (p+1) % BUF_SIZE;
        ++full;
        cond.notify_one();
        //cond.notify_all();
    }

    int get()
    {
        SCOPE_LOCK lock(mutex);
        if(full == 0)
        {
            {
                SCOPE_LOCK locl(io_mutex);
                cout<<"Buffer is empty.Wait..."<<endl;
            }
            while(full == 0)
            {
                cond.wait(lock);
            }
        }

        int i = buf[c];
    
        c = (c+1) % BUF_SIZE;
        --full;
        cond.notify_one();
        return i;
    }


private:
    boost::mutex     mutex;
    boost::condition cond;
    unsigned int p,c,full;
    int              buf[BUF_SIZE];
};

buffer buf;

void writer()
{
    for(int n = 0; n < ITERS;n++)
    {
        {
            SCOPE_LOCK(io_mutex);
            cout<<"sending:"<<n<<endl;
        }
        buf.put(n);
    }
}

void reader()
{
    for(int i = 0;i < ITERS;i++)
    {
        int n = buf.get();
        {
            SCOPE_LOCK lock(io_mutex);
            cout<<"receive:"<<n<<endl;
        }
    }
}

int main(int argc, char const *argv[])
{
    boost::thread t1(&reader);
    boost::thread t2(&writer);
    t1.join();
    t2.join();

    return 0;
}