boost :: thread生产者使用者

Question

I am new to boost::thread I am making a producer consumer with a Monitor. This is how I've coded it so far.

//{ Declarations in header
private:
  boost::condition_variable    _condition;
  boost::mutex                 _mutex;
  std::deque<RawMatrix*>       _queue;
  boost::detail::atomic_count  _count;
//}

void MatrixMonitor::deposit(RawMatrix* rawMatrix){
    boost::unique_lock<boost::mutex> lock(_mutex);
    _condition.wait(lock, boost::bind(std::less_equal<int>(), boost::ref(_count), max));
    _queue.push_back(rawMatrix);
    ++_count;
    _condition.notify_one();
}

RawMatrix* MatrixMonitor::withdraw(){
    boost::unique_lock<boost::mutex> lock(_mutex);
    _condition.wait(lock, boost::bind(std::greater_equal<int>(), boost::ref(_count), min));
    RawMatrix* elem = _queue.front();
    _queue.pop_front();
    --_count;
    _condition.notify_one();
    return elem;
}

Is that okay ? and one thing I can not understand is how would I design the Producer and Consumer now ? So far I've done

void MatrixProducer::produce(){
    boost::mutex::scoped_lock lock(_mutex);
    RawMatrix* matrix = rawMatrix();
    _monitor->deposit(matrix);
}
RawMatrix* MatrixProducer::rawMatrix(){/*Generates and returns a matrix*/}

But how can/should I run the produce() in some interval. and I don't know What I need to write in consumer. and who will have the ownership of this Producer, Consumer and Monitor ?

Answer 1

Is that okay ?

1. You shouldn't use one condition variable for two distinct predicates. Use one condition variable for the queue-full condition and one for the queue-empty condition, or you will end up with missing updates.

2. In your produce() function, you shouldn't lock a second mutex, if this is not necessary. If it's a necessary predicate to call rawMatrix(), you could at least release the mutex before calling deposit() to not lock two mutex. Every time you lock more than one mutex, you must be aware of possible dead locks. One way to avoid deadlocks is to lock mutex always in the very same order (a so called lock hierarchy).

how would I design the Producer and Consumer now ?

Designing your producer and consumer is up to you and depends highly on your requirements. A producer / consumer schema is used to decouple the producing of work load from the actual processing. It's a buffer for work.

who will have the ownership of this Producer, Consumer and Monitor ?

Depending on your design, it might make sense, that a Producer owns the queue and the queue owns the consumers.