C pthread

Introduction

Les thread ou processus légers sont utilisés pour paralléliser l'exécution dans un programme. Ils sont dit légers car ils s'exécutent dans le même contexte que le processus d'exécution principal qui les créés et consomme donc moins de mémoire / CPU.

Pré-requis

Pour pouvoir créer des threads il faut utiliser la librairie pthread (POSIX thread):

#include <pthread.h>

Ce qui donne en ligne de commande:

gcc -lpthread thread_exemple.c

Pour inclure la librairie dans Eclispe regardez ici.

Premier thread

Dans ce premier exemple nous allons créer un thread qui affiche une message:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
	printf("Nous sommes dans le thread.\n");
	// Arrêt propre du thread
	pthread_exit(NULL);
}

int main(void) {
	// Création de la variable qui va contenir le thread
	pthread_t thread1;
	printf("Avant la création du thread.\n");
	// Création du thread
	pthread_create(&thread1, NULL, thread_1, NULL);
	printf("Après la création du thread.\n");
	return EXIT_SUCCESS;
}

Dans cette exemple nous utilisons la fonction suivante:

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

• *thread est une référence vers la variable qui va contenir le thread;
• *attr correspond aux arguments de création du thread, passer à la fonction pthread_create;
• *(*start_routine) est un pointeur vers la fonction exécutée par le thread;
• *arg est un pointeur vers les arguments passés en paramètre à la fonction start_routine;
• le code retour de la fonction varie entre :
  • 0 → lorsque tout c'est bien passé;
  • EAGAIN → lorsque les ressources sont insuffisantes ou le nombre de thread maximum est atteint;
  • EINVAL → lorsque un argument invalide est passé en paramètre;
  • EPERM → lorsqu'il y a un problème de droit sur l'ordonnanceur (passé en paramètre);

Lorsque l'on exécute cet exemple on à le résultat suivant :

Avant la création du thread.
Après la création du thread.

On ne voit pas le message du thread car le programme se termine sans attendre la fin de son exécution. Pour attendre la fin de l'exécution du thread, il faut utiliser la fonction suivante :

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

• *thread est une référence vers la variable qui va contenir le thread;
• **retval est un pointeur vers un entier qui contiendra la valeur de retour du thread;
• le code retour de la fonction varie entre :
  • 0 → lorsque tout c'est bien passé;
  • EDEADLK → lorsqu'il y a un deadlock;
  • EINVAL → lorsque le thread n'est pas joignable;
  • ESRCH → si le thread n'existe pas;

Ajoutez la ligne suivante :

pthread_join(thread1, NULL);

Après l'appel de la fonction pthread_create pour avoir le résultat suivant:

Avant la création du thread.
Nous sommes dans le thread.
Après la création du thread.

Modification d'une variable

Dans cet exemple nous allons incrémenter dans le thread un entier qui est déclarer dans le processus principal:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
	int *i = (int *) arg;
	(*i)++;
	// Arrêt propre du thread
	pthread_exit(NULL);
}

int main(void) {
	// Création de la variable qui va contenir le thread
	int i = 1;
	pthread_t thread1;
	printf("Avant la création du thread, i = %i.\n", i);
	// Création du thread
	pthread_create(&thread1, NULL, thread_1, &i);
	pthread_join(thread1, NULL);
	printf("Après la création du thread, i = %i.\n", i);
	return EXIT_SUCCESS;
}

Cela donne le résultat suivant :

Avant la création du thread, i = 1.
Après la création du thread, i = 2.

On peut remarquer que:

• dans le processus principal, on passe une référence vers la variable i (&i) dans la fonction pthread_create;
• dans le thread on récupère le pointeur vers cette variable et on la déclare comme étant un entier :

int *i = (int *) arg;

• on incrémente le pointeur et non la variable elle même :

(*i)++;

Exclusion mutuelle

Lorsque l'on cherche à modifier dans plusieurs threads, une variable globale, il peut y avoir un problème d'accès concurrent (modification / lecture simultanée). Ce problème peut être réglé en utilisant ce que l'on appel un mutex (mutual exclusion).