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