Discussion :

[algabus]

Bonjour,
J'ai un souci avec les sémaphore Posix anonyme utilisés dans la synchronisation de threads. Je tiens d'abords à poser le contexte.. attention, accrochez-vous!

Mes threads permettent d'activer certaines sous-routines qui sont chacune liées à un flag. Ceux-ci sont testés dans une boucle infinie exécutée dans le thread qui est bloqué à chaque boucle par un sémaphore (sem_wait()). Avec le code, ce sera peut-être plus clair :

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
//fonction exécutée dans un thread détaché du fil d'exécution principal du programme
void maFonctionThreadee()
{
  while(true)
  {
    if(maSousRoutine1_activee)
    {
      maSousRoutine1_activee = false;
      maSousRoutine1_Privee();
    }
    else if(maSousRoutine2_activee)
    {
      maSousRoutine2_activee = false;
      maSousRoutine2_Privee();
    }
    //...
 
    //arrête le thread jusqu'à la prochaine activation
    sem_wait(&monSemaphore);
  }
}
 
//fonction public appelée depuis le fil d'exécution principal du programme
void MaSousRoutine1_Public()
{
  maSousRoutine1_activee = true;
  //activation de la boucle dans la fonction "threadée"
  sem_post(&monSemaphore);
}
 
//fonction privée, appelée depuis la boucle de la fonction "threadée"
void maSousRoutine1_Privee()
{
  //code traitement
}

Je dois interrompre ce thread de manière asynchrone.

J'arrive à le faire car lors de l'initialisation du thread, je paramètre l'activation des interruptions avec :

Code :

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

1
2
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

Et je l'interromps avec l'appel à la fonction :

Code :

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

pthread_cancel(referenceAuThread);

Le thread s'interrompt bien.
Lorsque je réinitialise le thread, je réinitialise en premier les flags d'activation relatifs aux sous-routines, ainsi que le sémaphore utilisé pour bloquer/activer la boucle de la manière suivante :

Code :

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

1
2
3
4
5
6
//destruction de l'ancien sémaphore
sem_destroy (&monSemaphore);
//initialisation du nouveau sémaphore
//(initialiser à 0, ainsi au premier sem_wait, il attendra jusqu'à qu'on active
//une des sous-routine et qu'un sem_post soit effectué).
sem_init(&monSemaphore, 0, 0);

Ensuite, l'initialisation du thread :

Code :

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

1
2
3
4
// le thread est detaché
pthread_attr_setdetachstate(&pthread_attr_t,PTHREAD_CREATE_DETACHED);
//initialise le thread et le lance dans la méthode maFonctionThreadee
pthread_create(&referenceAuThread, &pthread_attr_t, maFonctionThreadee)

Voilà, donc pour en arriver au fait.. J'arrive à interrompre mes threads, à les réinitialiser et à les relancer. Cependant, parfois de manière inattendue, après avoir relancer mes threads, lorsque j'effectue un sem_post sur le sémaphore monSemaphore pour activer la boucle, celui-ci s'incrémente bien (j'ai vérifié avec la fonction sem_getvalue()), mais le thread en attente sur le sem_wait dans la boucle infinie ne se débloque pas...

J'ai lu dans la doc MAN, que de faire un sem_destroy(&monSemaphore) alors que ce sémaphore a des threads en attente, peut amener un comportement indéfini :

“Destroying a semaphore that other processes or threads are currently blocked on (in sem_wait(3)) produces undefined behaviour.”

Linux MAN page



Est-ce que cela pourrait-il être la cause de mon problème? Pourtant, j'ai l'impression de tout réinitialiser proprement et deux fois sur trois, cela fonctionne très bien.. Vive les bugs de concurrence!

Merci d'avance pour votre aide, j'en ai un grand besoin!
Alex

[algabus]

Remarque :
J'ai bien testé les retours de chaque opération sur le sémaphore et le thread. Cela retourne bien systématiquement 0, ce qui indique que l'opération s'est bien exécutée.

[algabus]

J'ai obtenu une réponse sur un forum anglophone si jamais :
Linux forums

Il faut éviter d'utiliser les interruptions asynchrones sur les threads. Il faut plutôt utiliser les interruptions différées.