Discussion :

[wadcyr8_197]

Salut, comme l'indique mon titre, je suis en train de faire mon entrée dans le monde des threads et je galère un peu.

j'ai une classe TOTO de la forme : (je mélange déclaration et définition pour limité la longueur du post)

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
class TOTO
{
    public : 
    void recup_mesg()  // récupération des message
    {
       pthread_mutex_lock( &verrou ); 
       ret.nb=recv(info.id,ret.buf,1500,0); // info.id est une socket tcp
                                                //surlaquelle je recois des message en xml
       pthread_mutex_unlock( &verrou );
    }
    Recv get_mesg() // retourne ma variable
    {
       Recv temp;
       pthread_mutex_lock( &verrou );
       temp = ret;
       pthread_mutex_unlock( &verrou );
       return temp;
    }
 
    private : 
    Recv ret;
    pthread_mutex_t verrou;
}
 
 
//AVEC : 
typedef struct
{
    int nb;             // Nombre d'octets recus
    char buf[1500];
} Recv;

le principe c'est que j'ai un thread qui fais une boucle pour récupérer mes messages (et elle les place temporairement dans ma varaible ret) avec recup_mesg
et un autre thread qui est censé récupéré les message l'un après l'autre avec la fonction get_mesg pour les parser.

le problème c'est que si je fais un cout de ret.buf au niveau de la fonction recup_mesg, j'obtiens bien mon text xml brut, mais si je le fais dans la fonction get_mesg, j'obtiens un truc bizarre (en l'occurrence un m$ )

je vois pas vraiment d'où ça vient, je me demande si ça ne serait pas un problème de verouillage, mais je ne pense pas.

merci de votre aide !

[coyotte507]

Salut,

Je ne pense pas que ce soit un problème de verrouillage non plus, est-ce qu'on peut voir ton code cpp (tu peux le simplifier pour juste laisser le problème)?

coyotte507

[wadcyr8_197]

alors voilà ce que ça donne quand on "regroupe" mes différents fichiers :

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
--- definition des methodes et classes ---
 
class Listener
{
    public:
 
    Listener();
    void lecture(); // lecture sur la socket
    Recv get_buffer(); // renvoie du buffer
    void set_listener(Sock L_socket); //mis en place de la socket
 
    pthread_mutex_t verrou;
 
    private:
 
    Sock listener; // structure contenant la socket
    Recv ret;
 
};
 
 
void Listener::lecture()
{
    cout << "Lancement de la lecture" << endl;
    while (1)
    {
        ret.nb = -1; // on reset la variable
        memset (ret.buf, 0, sizeof (ret.buf)); // on reset la variable
        pthread_mutex_lock( &verrou );
        ret=recv(listener);
        pthread_mutex_unlock( &verrou );
        cout << "sortie 1" << ret.buf << endl;
    }
};
 
 
Recv Listener::get_buffer()
{
    Recv temp;
    cout << "sortie 2" << ret.buf << endl;
    pthread_mutex_lock( &verrou );
    temp = ret; // on stop dans un temps sinon on peut pas dévérouiller si on fait le return
    pthread_mutex_unlock( &verrou );
    return temp;
};
 
 
 
class Parseur
{
    public:
 
    Parseur();
    void make_parse(); // fct qui fait le parse !
    void action();
 
    private:
 
    Listener listen;
    Recv buffer;
 
};
 
 
void Parseur::action()
{
    while (1)
    {
        buffer.nb = -1;
        memset (buffer.buf, 0, sizeof (buffer.buf));
        buffer = listen.get_buffer(); // on récup le Recv de l'objet listener (en gros la variable ret)
        cout << "sortie 3" << buffer.buf << endl;
        make_parse();
    }
};
 
 
 
------Main------ 
 
// initialisation des deux objets
Listener ecouteur;
Parseur decoupeur;
 
lance un thread qui excute la methode Listener::lecture
x_Filament_Ameliore<Listener> fil_ecouteur(&ecouteur, &Listener::lecture);
 
lance un thread qui excute la methode Parseur::action
x_Filament_Ameliore<Parseur> fil_decoupeur(&decoupeur, &Parseur::action);
 
// et là ça merde ! :D

sur la sortie 1 j'obtiens bien mes messages xml brut les un après les autres
sur les sorties 2 et 3 j'ai un : m$ qui apparait.

voilà je crois que j'ai tout dit
merci du coup de main !

[loufoque]

Tes deux threads peuvent écrire au même emplacement mémoire au même moment.
Ça s'appelle un race condition, et c'est un comportement indéfini.

De plus, tu lis la donnée pendant qu'un autre thread peut être en train d'écrire dessus, donc c'est pas étonnant si le résultat n'est pas bon.

[wadcyr8_197]

De plus, tu lis la donnée pendant qu'un autre thread peut être en train d'écrire dessus, donc c'est pas étonnant si le résultat n'est pas bon.

mais le but d'utiliser des verrous c'est pas de palier à ce problème ?

[alpidor]

Salut,

Essaye de rajouter un autre mutex qui gere l'impression.

Je me demande egalement si ce ne searait pas pertinent d'avoir des mutex separes pour la reception et la transmission