Application multi-thread

Il s’agit de créer un programme composé de plusieurs fils d’exécution : plusieurs exécutions parallèles dans un unique processus.

1. La bibliothèque pthread

La bibliothèque pthread propose les fonctions :

pthread_create pour créer un thread

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                     void *(*routine)(void*), void *arg);

pthread_join pour attendre la fin d’un thread

int pthread_join(pthread_t *thread, void **thread_return);

pthread_exit pour sortir d’un thread
```
void pthread_exit(void *retval);
```

man pthread.h permet d’en savoir plus.

Exemple

void *f1(void *arg)
{
  /* ... */
  pthread_exit(NULL) ;
}

void *f2(void *arg)
{
  /* ... */
  pthread_exit(NULL) ;
}

void *f3(void *arg)
{
  /* ... */
  pthread_exit(NULL) ;
}

int main()
{
  pthread_t t1,t2,t3 ;

  if (pthread_create(&t1,NULL,f1,NULL)<0) perror("f1 fails\n") ;
  if (pthread_create(&t2,NULL,f2,NULL)<0) perror("f2 fails\n") ;
  if (pthread_create(&t3,NULL,f3,NULL)<0) perror("f2 fails\n") ;

  /* ... */

  pthread_join(t1,NULL) ;
  pthread_join(t2,NULL) ;
  pthread_join(t3,NULL) ;

  return 0 ;
}

la commande Unix ps -eLf montre les threads en cours d’exécution.

2. Passer des arguments

Le programme principal peut passer des arguments aux threads qu’il crée via l’argument arg de pthread_create.

3. La mémoire partagée

Dans l’exercice précédent, les accès simultanés aux variables globales shared et ind posent problème. L’exclusion mutuelle (mutex) consiste à garantir que dans une partie du code, appelée section critique, un processus est le seul à accéder à une ressource partagée. Schématiquement, cela donne :

pthread_mutex_t my_mutex ;	// déclaration du mutex
...
pthread_mutex_init(&my_mutex,NULL) ;	// initialisation du mutex, à faire 1 fois
...
pthread_mutex_lock(&my_mutex);	// début de section critique, attente bloquante

.../* ici, on est sûr d'être le seul à avoir verrouillé my_mutex */

pthread_mutex_unlock(&my_mutex);	// fin de section critique

Pour ne pas attendre que le mutex soit verrouillable, mais juste tester s’il est verrouillable, on peut utiliser pthread_mutex_trylock à la place de pthread_mutex_lock, qui rend aussitôt la main.