queue avec variables conditionnelles (boost)

queue avec variables conditionnelles (boost) - C++ - Programmation

Marsh Posté le 18-02-2013 à 19:07:13    

bonjour,
 
j'aimerais savoir si mon implémentation d'une queue avec deux threads (un consommateur et un producteur) vous parait correcte ?
 
merci par avance !
 
ps : j'ai fait avec boost.
 

Code :
  1. #include <queue>
  2. using namespace std;
  4. #include "boost/signals2/mutex.hpp"
  5. #include "boost/thread/thread.hpp"
  6. #include "boost/thread/condition.hpp"
  7. #include "boost/thread/locks.hpp"
  9. class MyQueue
  10. {
  11. public:
  12.     unsigned pop();
  14.     void push( const unsigned elem );
  16.     bool isEmpty() const;
  17. private:
  19.     std::list<unsigned> _queue;
  21.     mutable boost::signals2::mutex _mtx;
  23.     boost::condition _cond;
  25. };
  27. void MyQueue::push( const unsigned elem )
  28. {
  29.     boost::lock_guard<boost::signals2::mutex> guard( _mtx );
  31.     _queue.push_back( elem );
  33.     _cond.notify_one();
  35.     //unlocked on stack unwiding
  36. }
  38. unsigned MyQueue::pop()
  39. {
  40.     boost::lock_guard<boost::signals2::mutex> guard( _mtx );
  42.     while ( _queue.empty() )
  43.         _cond.wait( _mtx );
  45.     unsigned element = _queue.front();
  47.     _queue.pop_front();
  49.     return element;
  50. }
  52. bool MyQueue::isEmpty() const
  53. {
  54.     boost::lock_guard<boost::signals2::mutex> guard( _mtx );
  56.     return _queue.empty();
  57. }
  59. class Producer : public boost::thread
  60. {
  61. public:
  62.     Producer( MyQueue & q ) : _q( & q )
  63.     {
  64.         boost::thread( boost::BOOST_BIND(&Producer::run, this) );
  65.     }
  66.     void run()
  67.     {
  68.         for ( int i = 0 ;  ; ++i )
  69.         {
  70.             _q->push(i);
  72.             yield();
  73.             //boost::this_thread::sleep( boost::posix_time::milliseconds(1));
  74.         }
  75.         cout << "producer thread stopped." << endl;
  76.     }
  77. private:
  78.     MyQueue * _q;
  80. };
  82. class Consumer : public boost::thread
  83. {
  84. public:
  85.     Consumer( MyQueue & q ) : _q( & q )
  86.     {
  87.         boost::thread( boost::BOOST_BIND(&Consumer::run, this) );
  88.     }
  90.     void run()
  91.     {
  92.         while ( ! interruption_requested() )
  93.         {
  94.             int elem = _q->pop();
  95.         }
  96.     }
  98. private:
  99.     MyQueue * _q;
  100. };
  102. int main(int argc, char *argv[])
  103. {
  105.     MyQueue q;
  107.     Consumer consumer( q );
  108.     Producer producer( q );
  110.     consumer.join();
  111.     producer.join();
  114.     cin.get();
  115.     return 0;
  116. }

Reply

Marsh Posté le 18-02-2013 à 19:07:13   

Reply

Marsh Posté le 19-02-2013 à 14:46:57    

Techniquement, tu peux implémenter une queue thread safe sans mutex (si ta plateforme te garantit des écriture atomiques pour tes pointeurs, c'est assez simple)
 
edit : typo  :o


Message édité par theshockwave le 19-02-2013 à 14:47:19

---------------
last.fm
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed