[C] Initiation aux threads!

[Junky]

Bonjour.


0001: Introduction

Je suis en pleine "formation"/"amélioration de compétences" en C et j'ai pour habitude de partager ce que j'apprend. Voici pouquoi je vais vous parler des threads. Dans un premier temps, nous serons sur une utilisation standard des threads. C'est à dire la création de threads et leur exécutions. Dans un prochain tutoriel (si je l'écris bien sûr) je vous montrerai comment passer plusieurs arguments à un thread. En effet dans ce tutoriel nous en passerons qu'un seul car "techniquement" dans la déclaration de thread il n'est possible que d'en passer un.
Vous verrez qu'il n'y a rien de compliquer, et que la logique est plus de rigueur qu'autre chose. Je tiens à préciser que je suis un utilisateur Linux et que les tests, codes et lignes de commandes serons propres à ce système. Pour les personnes utilisant des systèmes différents, peux-être que certaines fonctions/options ne fonctionneront pas.

Aller c'est tipar!

0010: bibliothèque/include

Afin de pouvoir utiliser les threads il vous suffira de mettre en include pthread.h.

Code C :


#include <pthread.h>
 

Il vous sera aussi nécessaire de rajouter -lpthread dans la ligne de commande gcc.

Code C :


gcc -o main -o main.c -lpthread
 

0011: Les fonctions de pthread.

La fonction pour créer les threads:

Code C :


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

Sous linux, celle-ci renverra un int de type unsigned.

Un peu d'explications:
pthread_t thread: Ici c'est le nom de votre thread que l'on verra un peu plus tard, déclaré.
pthread_attr_t * attr: Ici c'est pour changer le comportement du thread. Je ne l'ai jamais utilisé pour être franc. Nous mettrons donc l'attribut NULL
void * (* start_routine) (void *): Ici c'est le nom de la fonction à executer. Il est bien sûr complètement possible d'avoir 2 threads qui tournent avec la même fonction. D'ailleurs nous le verrons car c'est que je vais vous montrer en dessous.
void * arg: L'arguments passé à notre fonction lancé par le thread... Nous ne pouvons en mettre qu'un seul. Pas possible d'en rajouter. Si vous désirez passer plusieurs arguments à un thread, il vous faudrat passer par les structures.

Fonction pour fermer un thread:

Code C :


void pthread_exit (void * valeur);
 

void * valeur:Argument récupéré par phtread_join()

Fonction pour cancel le thread

Code C :


int pthread_cancel (pthread_t thread);
 

pthread_t thread: Nom du thread à cancel.
A utiliser en faisant trés ATTENTION. En effet comme son nom l'indique, cette fonction permet d'exit un thread.

Dans le cas où vous utiliseriez les threads lock afin d'utiliser des ressources partagées entre threads (zone critique) et que vous killez le thread avant d'avoir unlock la ressource, celle-ci ne sera plus disponible pour les autres threads. Je n'aborderai pas ce sujet ici car il est à lui tout seul un tutoriel.

Fonction pthread_join

Code C :


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

Cette fonction est trés utile. Elle permet de "forcer" l'execution complète du thread avant la fin du programme. En effet imaginons que dans un thread nous avons un gros traitement a faire, le programme pourrait se finir avant l'exécution total du thread se qui pourrai être ennuyeux. Avec cette fonction, plus de souci.

pthread_t thread: Nom du thread
void ** valeur: Valeur de retour du thread.

Je n'ai pas mis toutes les fonctions. Pour plus d'informations, je vous invite à regarder cette page ci.

0100: La pratique

Donc comme on peut le deviner, nous allons réaliser un programme qui met en place 3 threads.
Rien de bien compliqué, il n'affichera qu'un int, avec leur numéro de threads.

Voici le code

Code C :


#include <pthread.h>
#include <stdio.h>  // printf()
#include <string.h> // strlen()
#include <unistd.h> // usleep()

/* Les sleep() sont seulement ici pour affiner l'affichage*/
void affichage(int *arguments){
    int i;

    for(i=0; i<5; i++){
        printf("Thread%d: %d\n", *arguments, i);
        sleep(3);
    }
}


int main(int argc, char* argv[]){
    /* Ici on déclare nos threads:*/
    pthread_t thread1;
    pthread_t thread2;
    pthread_t thread3;

    /* Nos threads afficherons un int et leur numéro de thread*/
    int nb1 = 1;
    int nb2 = 2;
    int nb3 = 3;
   
    /* Ici nous allons créer nos thread a l'aide de pthread_create()*/
    pthread_create(&thread1, NULL, (void *)affichage, &nb1);
    sleep(1);
    pthread_create(&thread2, NULL, (void *)affichage, &nb2);
    sleep(1);
    pthread_create(&thread3, NULL, (void *)affichage, &nb3);

    /* ON attend que nos threads soient terminés avant la fin du programme*/
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);

    return 0;
}

 

Et on le compile de cette manière:

Code C :


gcc -o thread thread.c -lpthread
 

Et voici la sortie:

Code C :


shut@M1nT ~/scripts/C $ ./thread
Thread1: 0
Thread2: 0
Thread3: 0
Thread1: 1
Thread2: 1
Thread3: 1
Thread1: 2
Thread2: 2
Thread3: 2
Thread1: 3
Thread2: 3
Thread3: 3
Thread1: 4
Thread2: 4
Thread3: 4
shut@M1nT ~/scripts/C $
 

Je ne rajouterai pas de commentaire sur le code, car j'en ai mis a l'intérieur de celui-ci. Pour une meilleure lecture en couleur de celui-ci, ca se passe ici.

Voilà j'espère avoir éclairé nos jeunes membres (jeune pas pour l'age mais pour les compétences en C).

0101 Conclusion.

Les threads sont trés utiles lorsque nous désirons réaliser des taches en parallèles, et vous serez forcément un moment ou a un autre obligé de les utiliser, donc autant le faire le plus tôt possible afin de pouvoir affronter la situation correctement lors de l'implémentation de threads dans des programmes plus complexes.

Je suis loin d'être UBER skilled (<= kikoulolz language ) en C, mais je trouve que ce language est vraiment bien. On reste sur un language puissant et très peu limité. Je connaissais celui-ci depuis des années, mais a part quelques "hello world!" je ne l'avais jamais utilisé réellement jusqu'à récement. Et now je dois en faire a peu près 7 a 8 heures par jour.
Même si cela pourrai être un autre débat, je pense que toutes personnes pratiquant le hacking (toutes sortes confondu) devrait réellement avoir des bases+++.

Bref en espérant que ceci vous aura aidé (pour ceux qui ne connaissent of course. )

Junky.