Skip to content

MOOC NSI - fondamentaux.

Transcription de la vidéo

4.2.3.2 : Ce que sont les threads

[00:00:01]

Voyons maintenant ce que sont vraiment les threads, Nous avons dit que les processus sont des processus lourds. Une des raisons pour cela, c'est que les processus ont besoin de beaucoup de ressources.Ils ont besoin d'un espace mémoire qui leur est dédié. Or, dans la plupart des cas, la mémoire est limitée et insuffisante. Si nous lançons deux fois le même code, typiquement deux fois l'interpréteur Python, vous savez qu'il va y avoir deux processus qui vont être créés, indépendants, différents. Les deux boîtes roses que vous voyez là ne sont rien d'autre que la mémoire qui est allouée aux deux processus. Nous avons vu qu'un processus représente l'exécution d'un programme, ce qui est la vision utilisateur. Voyons maintenant comment est géré un processus de point de vue du système. Vu qu'il occupe de la mémoire, il va se retrouver quelque part dans la mémoire vive de la machine. Dans cette mémoire, on va avoir déjà la mémoire dédiée au système d'exploitation et donc ensuite la mémoire pour un processus. En plus, on va voir la structure de contrôle qui permet de gérer le processus, structure qui se trouve dans la mémoire du système d'exploitation. Regardons maintenant ce qu'il y a à l'intérieur de la zone mémoire du processus. Il y a bien sûr les instructions à exécuter. C'est la zone texte. Dans la zone donnée. sont stockées les données qui sont connues avant l'exécution. Et dans les deux zones, tas et pile, nous avons les informations qui nous permettent de gérer la dynamicité du processus.

[00:02:02]

Dans le tas sont stockées des données qui apparaissent au fur et à mesure de l'exécution du processus, alors que la pile sert à gérer l'historique d'exécution et nous dit dans quelle fonction nous nous trouvons et depuis quelle fonction cette fonction a été appelée. Pour savoir quelle instruction il faudrait exécuter, il y a un registre dédié qui est le compteur de programme. Donc, si nous avons deux processus, même s'ils exécutent le même code, vu qu'ils ont deux zones mémoires indépendantes, on voit qu'il n'est pas possible de factoriser le code, alors, qu’il y en a besoin, dans beaucoup de cas, et il n'est pas possible d'avoir des données partagées pour communiquer, pour se coordonner. C'est pour ça que nous avons les threads. Les threads sont donc des processus légers qui sont gérés à l'intérieur des processus. Les threads vont nous permettre de faire la différence entre ressources et exécution, les ressources étant le code et les données, et l'exécution étant l'aspect dynamique d'un processus. Donc, avec les threads, il sera possible de factoriser du code, donc de partager du code, il sera possible de travailler sur des données partagées. Mais contrairement aux processus, les threads ne seront pas isolés. Cela va nous créer des problèmes quand nous aurons plusieurs threads, puisque ils pourront se gêner lors de leur exécution. Alors dans ce que vous avez vu jusqu'à maintenant, quand on avait des processus, nous avions dans la majorité des cas une seule exécution,

[00:03:54]

ce qui veut dire que nous avions un seul thread et donc c'était des processus mono-thread. Il est possible avec les threads, d'avoir plusieurs exécutions au sein du même processus. Pour cela, donc, on va avoir le code, les données et le TAS qui vont être des zones partagées. Mais pour gérer les différentes exécutions, il va falloir gérer plusieurs piles et on va obtenir des processus multi-threadés. En plus des piles, il va falloir gérer, dans le cas de mono thread, on a besoin d'un compteur de registre compteur de programme. Dans le cas multithread, nous allons avoir besoin de plusieurs compteurs de programmes pour les différentes exécutions. Donc, quand nous avons des threads au sein d'un processus nous avons plusieurs flots d'exécution qui s'exécutent en parallèle et de manière indépendante. L'ordonnancement des thread va créer des entrelacement comme avec les processus, et c'est quelque chose aussi qui ne peut être prévu. Les threads vont avoir accès à des données partagées et donc vont pouvoir communiquer. Les données partagées seront les données statiques, qui ne sont pas modifiables, et les données dynamiques qui, elles, sont modifiables.

Dans cette séquence nous avons introduit les threads. Les threads ou processus légers sont gérés au sein des processus et sont plus efficaces. Ils permettent la communication puisqu'ils partagent les ressources qui sont fournies par un processus. Néanmoins, la programmation parallèle avec threads est difficile, comme nous allons le voir dans les séquences à venir.