Bonjour,

J'ai trois problèmes dans l'utilisation de boost::thread (ça m'étonne qu'il y ait si peu de tutoriaux à ce sujet, le tutorial de developpez.com manque de réels exemples) :
  1. J'ai une donnée stockée dans le thread principal, qui est écrite par un thread de lecture de fichier et lue par un thread de calcul : est-ce qu'un mutex est quand même nécessaire, même s'il n'y a pas deux écritures en même temps ?
  2. Si oui, en utilisant l'encapsulation suivante, j'ai un paquet d'erreur de compilation pointant sur du boost::noncopyable... Que manque-t-il ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    //L'instance de cette classe est stockée via le thread principal
class A {
   //Données...
 
   boost::mutex m_data_mutex;  
 
   public:
      //Cette méthode est appelée par le thread de lecture de fichiers
      void write( /* data input */ ) {
         boost::mutex::scoped_lock lock(m_data_mutex);
 
         //Operation d'ecriture
      }
 
      /* data output */ read() {
         boost::mutex::scoped_lock lock(m_data_mutex);
 
         //Operation de lecture
      }
};
  3. Comment (visiblement quelque chose avec boost::condition) avertir un thread qu'une donnée est prête à être lue ? En fait, je pensais encapsuler comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    class Written_then_read {
    protected:
        Written_then_read() : m_ready(false);
 
        boost::mutex m_data_mutex;
        boost::condition m_cond;
 
        bool m_ready;
 
        typedef boost::mutex::scoped_lock Lock;
 
        Lock filling() {
            m_ready = true;
            m_cond.notify_one();
 
            return Lock(m_data_mutex);
        }
 
        void wait_for_fill() {
            Lock lock(m_data_mutex);
            while(!m_ready) {
               m_cond.wait(lock);
            }
        }
};
    ... Et l'utiliser comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    class A : private Written_then_read {
   //...
 
   void write( /* data input */ ) {
      Lock lock = filling();
 
      //Fill
   }
 
   /* data output */ read() {
      wait_for_fill();
 
      //Read
   }
 
   //...
};
    Mais cela ne pose-t-il pas des problèmes de copie à nouveau ?


Merci d'avance.

Cordialement,

Kidpaddle2

P.S: J'utiliserai probablement ce topic pour les problèmes relatifs à la résolution de ces questions