Discussion :

[lilocratch]

Bonjour,

J'essai de faire un programme qui lit et écrit en même temps. Le premier thread à terme sera différent mais ce sera qui il écrira continuellement sur le .txt.
Le deuxième thread doit traiter une par une les lignes du document quand elles sont complètes.
J'ai donc fait le programme ci-dessous avec level qui devrait indiquer le nombre de lignes et donc si il reste des lignes à traiter. Mais il n'affiche rien.

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <iostream>
#include <thread>
#include <windows.h>
#include <fstream>
#include <string>
#include <sstream>
#include <mutex>
 
using namespace std;
 
int main()
{   mutex lock;
    string line, checker;
    ostringstream data;
    int h=0,m=0,level=0;
    float s=0;
 
    fstream myfile;
    if (myfile.is_open()) myfile.close();
    myfile.open("data.txt",ios::out | ios::in | ios::trunc);
    thread t1 ([&h,&s,&m,&myfile,&data,&checker,&level](){
 
              while(1)
                {s+=0.1;
                if (s==60)
                    {s=0;m+=1;}
                if (m==60)
                    {m=0;h+=1;}
                if (myfile.is_open()){
                data<<h<<" "<<m<<" "<<s<<endl;
                checker=data.str();
                if(checker.find("\n")) level+=1;
 
                                     }
 
                Sleep(100);
 
 
 
              }
              });
    thread t2 ([&h,&m,&s,&myfile,&line,&level,&lock](){
 
               while(1){
 
 
                 if (myfile.is_open()&& level>0){
                    lock.lock();
                    myfile.seekg(0,myfile.beg);
                    getline(myfile,line);
                    lock.unlock();
                    cout<<line;
                    level-=1;
                 }
 
 
              }
              });
 
 
    t1.join();
    t2.join();
    myfile.close();
    return 0;
}

Merci pour votre aide.

[dalfab]

Bonjour,

L'avantage des threads c'est cela permet à d'avoir des flux d'exécution qui partagent un même espace mémoire.
Mais attention, il ne faut pas oublier l'énorme inconvénient des threads : on peut utiliser les mêmes données entre plusieurs threads! Et c'est souvent catastrophique.
Il faut donc tout faire pour qu'il n'y ait pas d'accès simultané aux mêmes données.
Le mieux est de n'avoir rien en commun et d'utiliser des mécanismes de communication.
Si on s'y est mal pris, en dernier ressort on peut utiliser des mutex ou des mécanismes de synchro.

Ici les objets utilisés par les deux threads : myfile et level.
Inversement un mutex qui ne serait utilisé que par un thread ne sert à rien (il faut garantir que les 2 ne font pas en même temps qqchose), donc lock n'est certainement pas utilisé correctement ici.
myfile est donc utilisé par 2 threads, ce qui n'a aucun sens. Cet objet est rempli de variables gérant la communication avec un fichier. On ne peut pas avoir 2 threads qui partagent cet objet. Attention, je n'ai jamais dit que deux threads ne pouvaient pas accéder à un unique fichier en même temps.

[Bktero]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int main()
{   mutex lock;
    string line, checker;
    ostringstream data;
    int h=0,m=0,level=0;
    float s=0;
 
    // reste du code
}

Woh ! On est plus en C89 ! Il faut déclarer et initialiser ses variables au plus proche de l'endroit où on commence à s'en servir ! Ca évite des erreurs et ça augmente surtout la lisibilité.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
fstream myfile;
    if (myfile.is_open()) myfile.close();

Je ne pense pas que le fichier puisse être ouvert vu que tu n'appelles pas open()...

Et sinon de manière plus globale, pourquoi passer par un fichier ? Ce qu'il te faut, c'est une queue protégée par un mutex que tu partages entre tes deux threads. Le thread producteur mets les éléments au fur et à mesure qu'ils sont prêts ; le thread consommateur les lit au fur et à mesure qu'il finit de traiter les précédents.

[lilocratch]

Merci pour vos réponses.

Donc si j'ai bien compris, je dois ouvrir le fichier avec un objet différent pour chacun de thread et mieux utiliser le mutex pour gérer la variable level .
Pour rapport à l'initialisation des variables: je la met just avant le thread 1 du coup?

Et sinon de manière plus globale, pourquoi passer par un fichier ?

J'ai besoin pendre les données qui arrivent par un port rs232 jusqu'au retour à la ligne. Le fichier me semblait une méthode adaptée puisque je pouvais écrire toutes les données qui arrivent et "couper" là où j'ai besoin.
Je ne connais pas très bien les queues. D'après ce que tu dit elles ont l'air de fonctionné sur le principe FIFO je vais me renseigner et peut-être essayer cette méthode.

Merci encore,

[Bktero]

En gros, ton thread T1 récupère des caractères depuis la liaison RS232, les mets dans un fichier, puis ton thread T2 relit le fichier pour le traiter ?

[lilocratch]

Oui,c'est ça.