Créer des threads en langage C (explications, principes de base, conseils)

Dans les systèmes d'exploitation modernes, une application peut se diviser en plusieurs fils. Les threads en C via POSIX, sont une notion à connaître, puisqu'ils permettent d'une part l'amélioration des performances sur un processeur multi-core, mais aussi de séparer chaque tâche et pouvoir en exécuter plusieurs "en même temps". Quelques concepts seront traités dans cet article, vous permettant de créer un thread, le fermer et protéger vos données.

Ouvrir un thread

La création d'un thread est assez simple. On utilisera la fonction "pthread_create", c'est aussi simple que cela. Elle comprend quatre arguments :
- int pthread_create(pthread_t * pth, pthread_attr_t *att, void * (*function), void * arg), où pth est un pointeur sur pthread_t, donnée qui stockera l'identifiant du thread créé,
- Un pointeur sur pthread_attr_t, structure qui vaut NULL par défaut, mais qui peut aussi contenir des modifications du thread.
- Le troisième argument est un pointeur sur fonction qui fonctionnera comme la fonction "main". Le thread s'arrêtera dès qu'il sortira de la fonction.
- Le dernier argument est similaire aux arguments argc et argv de la fonction "main". La fonction "pthread_create" renvoie un entier qui vaut 0 si la fonction s'est bien déroulée, et un autre entier sinon.

Fermer un thread

Dans la fonction du thread, on pourra utiliser "pthread_exit" pour terminer la fonction, ou tout simplement retourner un entier. En dehors de la fonction en revanche, la fonction "int pthread_cancel(pthread_t thread)" permettra d'arrêter un thread à partir de son identifiant. Elle renvoie 0 en cas de succès, un autre entier sinon.

Compilation

Il faudra penser à inclure l'en-tête suivant afin d'utiliser les fonctions de la librairie pthread :
#include
À la compilation, il faudra tout simplement ajouter l'option -l en appelant gcc, comme ceci : gcc programme.o -o programme -lpthread.
Votre programme est désormais compilé.

Protéger vos données

Les applications multi-thread peuvent utiliser un mutex (similaire au mot-clé "synchronized" pour les threads en Java) ou un sémaphore pour protéger vos données. Techniquement, un mutex doit être déverrouillé (pthread mutex unlock) par le même thread qui l'a verrouillé (pthread mutex lock), mais certains systèmes d'exploitation autorisent n'importe quel thread à le faire.
Le sémaphore a un autre fonctionnement. Elle compte jusqu'à zéro, donnant donc un certain nombre d'accès aux threads l'utilisant. Une fois le sémaphore à zéro, un thread devra l'incrémenter pour l'utiliser de nouveau. Une sémaphore n'autorisant qu'un seul accès aux données agira comme un mutex, à la différence que n'importe quel thread pourra y accéder.