Introduction aux threads

Un thread est un processus unique servant à exécuter du code. Lors de l'exécution de programmes, un thread est lancé et le code est exécuté. C'est ainsi que chacun des programmes sont lancés depuis le tout début.

Thread unique

Imaginons un programme simple qui effectue deux tâches longues : Télécharger un fichier et trouver le prochain nombre premier :

flowchart
    url[Demander un URL] --> nombre[Demander un nombre]
    nombre --> telecharger(Télécharger le fichier donné par l'URL)
    telecharger -- Longue attente --> fichier[(fichier.bin)]
    fichier --> trouver(Trouver le prochain nombre premier)
    trouver --> premier[Affichage à l'écran]

Si toutes les instructions sont effectuées dans un seul thread, le tout est linéaire. On devra attendre que le fichier soit téléchargé au complet avant de commencer le calcul du prochain nombre premier. Ce n'est pas très efficace.

Plusieurs threads

En utilisant une approche multi-thread, on pourrait lancer les deux tâches dans des threads séparés. Ceci aurait comme résultat d'effectuer les tâches simultanément :

flowchart TB

    subgraph thread1[Premier thread]
    direction TB
    telecharger(Télécharger le fichier donné par l'URL) -- Longue attente --> fichier[(fichier.bin)]
    end

    subgraph thread2[Second thread]
    direction TB
    trouver(Trouver le prochain nombre premier) --> premier[Affichage à l'écran]
    end

    subgraph main[Thread principal]
    direction TB
    url[Demander un URL]
    --> nombre[Demander un nombre]
    --> continuer[Continuer le processus]
    --> continuer2[D'autres instructions]
    end

    nombre -.-> thread2
    url -.-> thread1

Dans ce second exemple, on démarre un nouveau thread après chaque question. Le thread effectuera son travail pendant que le thread principal continue son exécution.

Client et serveur

Ce dernier exemple reprend l'application du blackjack. Une seule personne pouvait jouer au blackjack à la fois :

flowchart LR

    serveur[Le serveur]
    client1[Client 1]
    client2[Client 2]
    client3[Client 3]

    client1 --> c1{{Veut jouer}} -- Connexion réussie --> serveur
    client2 --> c2{{Veut jouer}} -- Connexion impossible --- serveur
    client3 --> c3{{Veut jouer}} -- Connexion impossible --- serveur

    linkStyle 1 stroke:#0f0,stroke-width:4px,color:blue;
    linkStyle 3,5 stroke:#ff3,stroke-width:4px,color:red;

Le client n'ayant qu'un seul thread, il ne pouvait s'occuper que d'un seul client à la fois. Avec la venue du multi-thread, il serait alors possible de gérer chaque connexion dans un thread séparé et ainsi d'avoir plusieurs client en même temps :

flowchart TB

    subgraph LeServeur[Le serveur]
        subgraph th1[Thread Client 1]
        j1[Jouer au blackjack]
        end

        subgraph th2[Thread Client 2]
        j2[Jouer au blackjack]
        end

        subgraph th3[Thread Client 3]
        j3[Jouer au blackjack]
        end

        subgraph main[Thread principal]
        attendre
        end
    end

    attendre["Attendre une connexion (accept())"]
    client1[Client 1]:::client1
    client2[Client 2]:::client2
    client3[Client 3]:::client3

    client1 --> c1{{Veut jouer}} -- Connexion réussie ---> LeServeur
    client2 --> c2{{Veut jouer}} -- Connexion réussie ---> LeServeur
    client3 --> c3{{Veut jouer}} -- Connexion réussie ---> LeServeur

    attendre -.-> th1:::client1
    attendre -.-> th2:::client2
    attendre -.-> th3:::client3

    classDef client1 fill:#090
    classDef client2 fill:#900
    classDef client3 fill:#00F,color:#FFF
    linkStyle 1,3,5 stroke:#0F0,stroke-width:4px,color:blue;

Non seulement plusieurs clients pourront jouer au blackjack, mais il serait même viable de les faire jouer ensemble.