Discussion :

[silenteagle]

Bonjours,
J'ai un thread qui exécute ceci :

Edition : ajout du code

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
void *task_write_in_buffer (void *p)
{
    struct data *p_data = p;
    struct shared *psh = p_data->psh;
    sFIFO *pTempfifo = psh->pfifo;
    char buff[40];
    int i = 0;
 
    if(p != NULL )
    {
        while(1)
        {
            sprintf(buff,"%s : %d\r\n", p_data->sid,i);
 
            pthread_mutex_lock (&psh->mut);
 
                fifoenter(pTempfifo,buff);
 
            pthread_cond_signal (&psh->synchro);
            pthread_mutex_unlock (&psh->mut);
 
            i++;
 
            msleep (500);
        }
    }
    return NULL;
}
        }

J'ai une fifo partagée entre plusieurs threads, celui ci dessus qui y ajoute une chaîne de caractère.
Et un autre qui dépile et affiche le contenue de la pile.

Je me suis rendu compte que si je crée deux thread qui exécute le code ci-dessus, la variable "i" est partagé entre eux

Comment ce fait t'il que i soit partagé entre les deux thread et comment ce fait t'il qu'il n'est pas était décrémenté (cf ci-dessous en vert) ?

Sortie du thread qui depile la fifo :
task A : 1
Task C : 2
Task C : 3
task A : 4
Task C : 5
task A : 6
Task C : 7
Task C : 7
task A : 8
Task C : 9
Task C : 10

Merci d'éclairer ma lanterne

[Neckara]

Bonjour,

Il est difficile de répondre alors qu'on ne sait pas comment tu as déclaré i ni même comment tu l'as transmis à la fonction qui effectue le traitement.

Mais je suppose que i est une variable globale ?

[Metalman]

Je rajouterais juste à la remarque et aux questions de Neckara : n'oublie pas que les threads travaillent "avec" le processus dans le même AS !
Du coup les variables globales et la mémoire sont partagées !

[silenteagle]

Ah oui ^^
J'avais mit le minimum de code pour pas surcharger le poste

i est une variable locale, c'est bien là le problème.

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
void *task_write_in_buffer (void *p)
{
    struct data *p_data = p;
    struct shared *psh = p_data->psh;
    sFIFO *pTempfifo = psh->pfifo;
    char buff[40];
    int i = 0;
 
    if(p != NULL )
    {
        while(1)
        {
            sprintf(buff,"%s : %d\r\n", p_data->sid,i);
 
            pthread_mutex_lock (&psh->mut);
 
                fifoenter(pTempfifo,buff);
 
            pthread_cond_signal (&psh->synchro);
            pthread_mutex_unlock (&psh->mut);
 
            i++;
 
            msleep (500);
        }
    }
    return NULL;
}

[deletme]

Salut,

Après une lecture rapide du code, ta variable i est utilisée hors de la zone critique, donc potentiellement, les deux threads peuvent y accéder "simultanément". Essayes en passant le i++ avant de libérer le sémaphore.

Cdlt, dM

[Bktero]

Je suis étonné du comportement. La variable i est une variable locale non statique donc j'aurais tendance à penser que chaque thread en possède sa propre instance.

Ton code ne permet pas de reproduire le problème, ce serait gentil d'en fourni un.

Perso, j'ai essayé de reproduire le soucis avec le code suivant mais il ne reproduit 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
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <windows.h>
 
 
#include "pthread.h"
 
static pthread_mutex_t mutex_screen = PTHREAD_MUTEX_INITIALIZER;
 
void *task(void *p)
{
    int i = 0;
 
    while(1)
    {
        pthread_mutex_lock(&mutex_screen);
        printf("%s = %d\n", p, i);
        pthread_mutex_unlock(&mutex_screen);
        i++;
        Sleep(1000);
    }
    return NULL;
}
int main(void)
{
    pthread_t thread_1;
    pthread_t thread_2;
 
    pthread_create(&thread_1, NULL, task, (void*)"T1");
    pthread_create(&thread_2, NULL, task, (void*)"T2");
 
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    return 0;
}