#include <iostream>
#include <queue>
#include <unistd.h>
 
#include <boost/thread.hpp>
 
#include <openssl/sha.h>
 
// Compiled as:
// g++ -Wall boost_producer_consumer.cpp -pthread -lboost_thread-gcc-mt -lcrypto
 
std::queue<int> theQ;
 
const size_t kmessage_size = 3000000;
const size_t knum_iterations = 200;
 
class buffer
{
    public:
        void put(const std::vector<unsigned char> &msg)
        {
            std::cerr << "#" << std::endl;
            boost::mutex::scoped_lock sl(mutex);
            while (q.size() >= kBuffSize)
                cond.wait(sl);
 
            q.push(msg);
            cond.notify_one();
        }
 
        std::vector<unsigned char> get()
        {
            boost::mutex::scoped_lock sl(mutex);
            while (q.empty())
                cond.wait(sl);
 
            const std::vector<unsigned char> ret = q.front();
            q.pop();
            cond.notify_one();
            return ret;
        }
 
    private:
        static const size_t kBuffSize = 5000;
        boost::mutex mutex;
        boost::condition cond;
        std::queue< std::vector<unsigned char> > q;
};
 
buffer buf;
 
void producer()
{
    for (size_t i = 0; i < knum_iterations; ++i) {
        std::vector<unsigned char> msg;
        msg.reserve(kmessage_size);
        for (size_t j = 0; j < kmessage_size; ++j) {
            msg.push_back(rand() % 256);
        }
        buf.put(msg);
    }
    std::cerr << "Done" << std::endl;
}
 
void consumer()
{
    for (size_t i = 0; i < knum_iterations; ++i) {
        const std::vector<unsigned char> msg = buf.get();
        unsigned char md[SHA_DIGEST_LENGTH];
        SHA1(&(msg[0]), msg.size(), md);
        std::cout << i << " *****************" << std::endl;
        for (size_t j = 0; j < SHA_DIGEST_LENGTH; ++j) {
            std::cout << static_cast<int>(md[j]);
        }
        std::cout << std::endl;
    }
}
 
int main()
{
    boost::thread p(producer);
    boost::thread c(consumer);
 
    p.join();
    c.join();
}