Discussion :

[grego91000]

Bonjours (ou bonsoir ?) à tous, je suis vraiment (mais alors mais très) nouveau sur le multithreading et en essayant une chose qui est d'utiliser un Thread pour écrire dans une variable en continue et le Thread du main pour lire cette même variable, j'ai un problème qui est que la variable ne change pas de valeur dans le main mais pourtant elle change dans le 1er Thread, alors je me demandais si il y avait une solution pour utiliser la même variable sur deux Threads.

Je vous remercies d'avance pour vos réponse (et s'il vous plaît, c'est la première fois que je touche au multithreading alors soyez indulgents svp ^^)

[Matt_Houston]

Ta variable est une ressource partagée dont il faut encadrer l'accès par une primitive d'exclusion mutuelle, tu ne peux pas y lire et y écrire comme d'habitude, freestyle. D'autre part ta configuration semble correspondre à un problème de producteur-consommateur pour lequel il existe diverses solutions. Pourrais-tu nous donner plus de détails ?

[Bousk]

Un peu de code aiderait à y voir plus clair.
Dans le main tu as une valeur copiée depuis ta variable, peut-être tout simplement parce que tu la copies, peut-être parce que le compilateur la copie pour toi pensant à une optimisation.
Utiliser des std::atomic de la bonne manière permettrait d'éviter ça dans un premier temps, comprendre comment fonctionne thread et mutex feront aller plus loin.

[grego91000]

Merci pour vos réponses rapides, pour le bout de code voici la partie pour laquelle je pose la question:

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
int my_thread(void *data)
              {
                   VariableClasse vc;
                   int a;
 
                   while (continuer) //Variable à part
                   {
                        a++;
                        vc.setVariable(a);
                   }
 
              }
int main()
              {
                   SDL_Thread *thread;
                   thread = SDL_CreateThread(my_thread, MainScreen); //Démarre le Thread 
                   VariableClasse vc;
                   int a;
                   while (continuer)
                   {                
                        a = vc.getVariable(); //Cette variable est la même que celle qui est "set"
                   }
               }

Et après pour voir l'état des deux variables, j'ai décidé de mettre un ofstream dans le Thread du haut qui pas dans un fichier texte et ça fonctionne bien pour lui, par contre pour celui du main je le fais aller dans un autre fichier texte mais la variable ne change jamais.

[Matt_Houston]

Mouais.. ce n'est pas très clair tout ça. Tu n'aurais pas un exemple minimal réel (qui compile) pour voir ?

En l'état tu as deux variables vc différentes puisqu'il y a une déclaration dans chaque thread. Se pourrait-il que tu aies aussi cela dans ton programme ? Auquel cas rien d'étonnant à ce que la variable du main thread reste inchangée : c'en est une autre. Tu dois transmettre au worker thread des références aux ressources partagées via ses arguments (void *data).

Ensuite, il reste encore à encadrer les accès à ces ressources (get, set) par des verrous. Je ne sais pas quelles sont les primitives disponibles avec SDL.

[grego91000]

Pour l'exemple minimal, celui =-ci devrai compiler (je dis bien devrai car depuis peu, me projets SDL finissent tous avec des status comme -1073741510 etc...)

Main.cpp:

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
#include <SDL/SDL.h>
#include <SDL/SDL_thread.h>
#include "Ennemis.h"
#include <fstream>
using namespace std;
 
SDL_Thread *thread;
 
int continuer;
 
int my_thread(void *Data)
{
    int positionX = 1000;
    int positionXJoueur = 0;
    Ennemis e;
    ofstream fichier("testThread.txt", ios::out | ios::trunc); //Utilisation de ofstream car la console n'affiche rien ni pendant le débogage ni après
    while (continuer)
    {
 
        while (positionX > positionXJoueur + 50) //PositionX est celle du bot
        {
            positionX-=2;
            e.setPositionX(positionX);
            fichier << positionX << endl;
 
        }
 
    }
    fichier.close();
}
 
int main ( int argc, char** argv )
{
 
    SDL_Surface *ecran = NULL;
    SDL_Event event;
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(1000, 500, 8, SDL_DOUBLEBUF | SDL_HWSURFACE);
 
    Ennemis e;
    int positionX = 1000;
 
    ofstream fichier("testMain.txt", ios::out | ios::trunc);
 
    thread = SDL_CreateThread(my_thread, NULL);
    while (continuer)
    {
 
        SDL_WaitEvent(&event);
        switch (event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
        }
        positionX = e.getPositionX();
        fichier << positionX << endl;
    }
    fichier.close();
}

Ennemis.h:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <SDL/SDL.h>
 
class Ennemis
{
    public:
        Ennemis();
        void setPositionX(int X);
        int getPositionX();
 
    private:
        int positionXG; //Position X Accessible par tous avec les fonctions Set et Get
 
};

Ennemis.cpp

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
#include "Ennemis.h"
 
int Ennemis::getPositionX()
{
    return Ennemis::positionXG;
}
 
void Ennemis::setPositionX(int X)
{
    Ennemis::positionXG = X;
}
 
Ennemis::Ennemis()
{
    Ennemis::positionXG = 1000;
}

Et il existe juste des Mutex à initialiser et utiliser dans les fonction SDL_MutexP(SDL_Mutex *mutex) pour ouvrir le mutex et SDL_MutexV(SDL_Mutex *mutex) pour le fermer.