souci de mutex

Bonjour,

Utilisant la librairie portable pthread:
http://emmanuel-delahaye.developpez....#helloworlds_1

J'ai voulu protégé le lancement de thread par une variable Status.

Bien qu'il s'agisse de code C++, je poste ceci sur ce forum car je considère que pthread est du C.

Le code d'appel est le suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 string run(const string action, char* strAutomat) { if (getStatus() != S_WORKING) { setStatus(S_WORKING); // Start Thread of opening pthread_t ta; pthread_create (&ta, NULL, staticOpenCall, strAutomat); } return status; }
La protection par mutex est simple:
Code:

1 2 3 4 5 6 7 void setStatus(const string newStatus) { pthread_mutex_lock (&mutexStatus); status = newStatus; pthread_mutex_unlock (&mutexStatus); }
Le mutex est correctement initialisé au démarrage
Code:

1 2 mutexStatus = PTHREAD_MUTEX_INITIALIZER;
Le problème est que lorsque le thread se termine, il fait :

Code:

setStatus(S_CLOSED);

(S_CLOSED n'est qu'une constante)

Et là, lors de cette initialisation, j'ai une erreur d'accés mémoire dans la ligne
pthread_mutex_lock() de setStatus().
Il est à noter que cette fonction a été appelé précédement par Run() (voir plus haut) et que cela s'est bien passé.

Je suis sous Windows XP, avec VisualC++ 2005 Express, mais ceci ne devrait pas entrer en compte car je souhaite faire du code portable.

Merci

Peux tu montrer comment tu fais la déclaration du mutex (et a quel moment tu fais son initialisation) ?

Sinon, j'ai une petite remarque a propos du code de la fonction run().
Code:

1 2 3 4 5 6 7 8 if (getStatus() != S_WORKING) { setStatus(S_WORKING); // Start Thread of opening pthread_t ta; pthread_create (&ta, NULL, staticOpenCall, strAutomat); }
En toute rigueur, status peut être modifié entre getStatus et setStatus.
Si tu veux vraiment protéger le lancement, il serait preferable de faire quelque chose du genre
Code:

1 2 3 4 5 6 7 8 9 10 pthread_mutex_lock (&mutexStatus); if (status != S_WORKING) { status = S_WORKING; // Start Thread of opening pthread_t ta; pthread_create (&ta, NULL, staticOpenCall, strAutomat); } pthread_mutex_unlock (&mutexStatus);

Voici le code de la déclaration:

Code:

1
2
3
 
        // Protection of status
        pthread_mutex_t mutexStatus;

La protection du mutex proposée n'est pas idéale car le thread modifie la variable.
Par contre, je peux adapter cela:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
     pthread_mutex_lock (&mutexStatus);
	if (status != S_WORKING)
	{
             status  = S_WORKING;
        pthread_mutex_unlock (&mutexStatus);
	     // Start Thread of opening
             pthread_t ta;
	     pthread_create (&ta, NULL, staticOpenCall, strAutomat);
        }
        else
        {
        pthread_mutex_unlock (&mutexStatus);
        }

Des commentaires ?

Finalement les mutex ont l'air de fonctionner.

Il y a un souci ailleur...

Citation:

Envoyé par Bayard

La protection du mutex proposée n'est pas idéale car le thread modifie la variable.

Ben justement, il vaudrait mieux du coup protéger la fonction par un mutex, pour etre sur d'être dans un état cohérent à la sortie de la fonction.
Je pense aussi que la mise à jour de status ne se fait pas au bon endroit, il faut verifier avant que le thread a bien été créé.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 pthread_mutex_lock (&mutexStatus); if (status != S_WORKING) { // Start Thread of opening int res; pthread_t ta; res = pthread_create (&ta, NULL, staticOpenCall, strAutomat); if (res==0) status = S_WORKING; else status = S_ERROR; } pthread_mutex_unlock (&mutexStatus);
Si tu separes la declaration et l'initialisation, je te conseille plutot d'utiliser pthread_mutex_init, pour l'initialisation du mutex.