Session du 11 novembre 2024 à 21h00
TOSA & Certifications
Librairie Standard & Modules
Deviens membre Premium magic_button
Cette session de mentorat est réservée aux membres Premium. Rejoignez-nous pour accéder à toutes les rediffusions des sessions de mentorat !
Premium
- check +100h de formations
- check +180 exercices de code
- check +100h de mentorats en rediffusion
- check 20 projets
- check Mentorats groupés hebdomadaires
- check Support individuel avec nos mentors
Session de mentorat TOSA
Mentorat sur le module threading
00:00:00 :Est-ce qu'il y en a qui ont déjà utilisé threading et multiprocessing ?Threading, il y a plusieurs années déjà. Ça a sûrement évolué.Notamment, je ne l'utilise pas forcément que pour l'exemple, sinon je n'en ai pas forcément besoin.
00:00:25 :Participer à l'extérieur, ok.C'est parti alors.En fait, avec Python, vous avez ce qu'on appelle le GIL, c'est le Global Interpreter Lock.En fait, ça vous empêche d'exécuter du code, par exemple des tâches, de manière parallèle.
00:01:01 :On va montrer avec des exemples.Le but, c'est qu'on exécute du code.Par exemple, on va avoir deux fonctions qui vont s'exécuter l'une après l'autre.
00:01:17 :Avec un time.sleep, par exemple, pour simuler comme si on avait une requête qui était longue ou quelque chose dans le genre.En temps normal, si on appelait deux fois la fonction, si on avait un time.sleep de 3, ça durerait 6 secondes.
00:01:32 :Mais là, on va voir comment on peut faire ça, exécuter notre fonction en parallèle.Ça va être plus parlant si je vous montre ça.Tout l'écran, l'écran 1.
00:01:46 :Sur VS Code, c'est commande plus, je crois.Ouais, c'est bon.Alors, c'est parti.On va commencer avec un exemple.On va apporter time.Hop là.
00:02:12 :Avec le gil, on va avoir un seul thread.On va voir que tout s'exécute de manière séquentielle.Ça, la plupart, vous le savez.On va avoir, par exemple, une tâche longue.
00:02:29 :On va lui donner un nom, ici.On va faire print.On va avoir...Pour bien s'y retrouver, on va faire début de...J'ai mis name ou non, je ne sais plus.
00:02:41 :Je mets un coup en anglais, un coup en français, ce n'est pas grave.On va simuler ici, comme si on avait une requête de réseau qui allait prendre 3 secondes, par exemple.
00:02:49 :On va printer, et là, on va mettre fin de name.OK.Et maintenant, ce qu'on va faire, on va avoir notre tâche longue.Elle va s'appeler test 1.
00:03:06 :Et on va avoir...Une deuxième.Voilà.Et là, quand on va exécuter...On a bien le début du test 1, on va attendre 3 secondes.
00:03:21 :Fin du test 1, début du test 2, on attend encore 3 secondes.Et voilà, on a fini.Donc là, en tout, on a attendu nos 6 secondes.
00:03:27 :Si vous avez des questions au fur et à mesure, n'hésitez pas.Je vais essayer d'avoir ça qui...Tac.Voilà.J'ajuste un peu mes écrans, là.
00:03:41 :C'est bon.Et donc, on va voir ici, comment on peut faire avec threading,pour ne pas qu'à chaque fois, en fait, on attende 3 secondes que ça s'exécute,et encore 3 secondes.
00:03:50 :On va essayer de lancer tout ça en même temps.Et donc, threading, ici.Et on va gérer ça autrement.Donc là, vous pouvez gérer ça comme ça.
00:04:03 :On va voir...Donc, parce qu'avec...Comme je disais, avec Python, on va avoir un seul...Ah.Alors, attendez.Salut, Etienne.Alors.Tac.Etienne, c'est bon, t'as rejoint.
00:04:26 :Ouais, c'est bon.Tac.Voilà.Donc, oui.Donc, je disais qu'on avait notre thread qui s'exécutait.Mais là, on va s'amuser.On va en créer, en fait, plusieurs.
00:04:41 :Tac.Donc, vous allez voir.J'ai Google Meet qui me fait un...Voilà, c'est bon.Donc, on va avoir le premier.On va faire...Donc, on utilise la librairie native.
00:04:54 :Threading.Thread.Hop.Oh là.Threading.Thread.Hop.Et là, ici, on va noter notre tâche longue.Ici, notre fonction.Et, en argument, on va avoir...
00:05:10 :Donc, on va l'appeler.On va l'appeler chiffre test1.On va refaire pareil.Test1.Et là, on va en créer un deuxième.Hop.Et ici, on va appeler test2.
00:05:26 :Voilà.Et...Et...Pas de...Qu'est-ce qu'il y a ?J'ai pas compris.C'est les tiennes.J'ai un panneau.C'est moi.Donc...Du coup, après, tous nos threads ici,il va falloir les démarrer.
00:05:52 :Donc, on va utiliser start.Là, en gros, c'est comme si on démarrait le moteur.Et, on va dire qu'on va vouloir attendre la fin des threadspour que la suite du programme s'exécute.
00:06:07 :J'ai un lag.Voilà.Join.Thread2.join.Et voilà.Le join, ici, ça va permettre...On va faire en sorte que les threads s'attendent.Ils vont attendre qu'ils vont se terminerpour pouvoir passer, par exemple, au...
00:06:27 :Pour le print de terminer.Sans ça, sinon, ça ira directement ici.Donc là, si je fais ça...Tout à l'heure, on avait 6 secondes.Et là, si je lance...
00:06:35 :Hop.J'ai bien les deux qui sont lancés.Et les deux qui sont lancés,et les deux terminent en même temps.Donc là, on a pris 3 secondes.
00:06:45 :Ça ne s'est pas exécuté de manière séquentielle.Ça s'est exécuté, en fait, en...Il y a deux threads, en fait, qui se sont lancées.En gros, ce qui s'est passé, ici,c'est que, pendant le time.sleep, en fait,
00:07:00 :on parlait du GIL,en fait, l'interpréteur global, l'interpréteur Locke,il s'est libéré,et il a été sur...Ça a permis d'aller sur le thread numéro 2, en fait.
00:07:17 :Donc, en fait, ici, ils vont se partager le GILde manière coopérative, on va dire, en gros.Donc, ils vont se le partager.Voilà.Est-ce que, pour l'instant, ça va ?
00:07:28 :Je ne sais pas.Merci.C'est tout.Avec.Merci.Super.OK.Alors, c'est pas fini.Donc, là, on a...Ils sont partagés le GIL de manière coopérative,il n'y a pas de problème.
00:07:52 :Maintenant, ça pourrait, en fait,il pourrait s'il y avoir des petits problèmes.Si, par exemple, on va recommencer avec une autre fonction,donc on va faire un def...
00:08:02 :Vous allez voir.On va se mettre une variable.Voilà.Ça va être rigolo.On va avoir un compteur, ici, qui va être égal à 0.
00:08:12 :Donc, on va avoir une variable,et on va faire un truc un petit peu salequi ne se fait pas forcément.On va accéder à notre variable.
00:08:21 :D'ailleurs, est-ce que c'est possible d'avoir un compteurqui va être égal à 0 ?Est-ce que c'est possible d'avoir un compteurqui va être égal à 0 ?
00:08:31 :D'ailleurs, est-ce que c'est bon pour tout le monde, ça,la manière d'accéder à une variable globale dans la fonction ?Le global, tout le monde le connaissait, ça ?
00:08:42 :OK.OK.OK.Oui, c'est bon.Super.OK.Donc, après, faire ça, c'est pas forcément...Je ne l'ai jamais vu en vrai.Pour l'instant, dans la vie pro de dev,je ne l'ai jamais vu.
00:08:59 :Peut-être que ça se fait,mais ce n'est pas forcément ce qu'il y a de mieuxd'accéder à une variable globale comme ça dans une fonction.
00:09:06 :Je ne sais pas.J'y réfléchissais, mais je sais que souvent,il y en a, quand ils voient ça, ils font la tête.Ils n'aiment pas ça.
00:09:12 :Mais là, c'est pour l'exemple.Donc, on va avoir current.Vous allez voir ce que je vais faire.Compteur, ici.Et on va avoir un time pour un slip.
00:09:20 :On va mettre carrément 5.Et notre compteur, ça va être égal àcurrent plus 1.Voilà.Et donc, on va avoir nos threads, ici.On va faire une liste.
00:09:41 :Pareil pour ceux qui passent le SLOZA.Pour ceux qui débutent, surtout.La liste, je peux très bien la créer comme ça.Je peux très bien la créer comme ça.
00:09:51 :Il n'y a pas de problème.Donc, j'ai ma liste.Et on va faire un for.In range, parce qu'on ne va pas se servir de la variable qui est ici.
00:10:02 :Donc, on a un range 5.Et on va faire t est égal à threading.thread.Et ici, on va avoir en target.On va incrémenter sans lock.
00:10:17 :Et c'est tout.Il n'y a pas d'argument.On va s'amuser.Là, on va ajouter à notre liste de threads, celui qu'on vient de créer.On va en créer plusieurs.
00:10:32 :Et à chaque fois, on va faire un start.Ça se voit souvent quand on fait du threading, d'avoir cette boucle, cette forme-là.Votre threading.thread.Ensuite, vous ajoutez la liste.
00:10:44 :Et après, vous faites votre start.Sauf qu'à la fin, il faut penser à faire un join.Et ici, on va faire notre join.Et à la fin, on va printer le compteur.
00:11:14 :Donc, on accède à notre variable globale.On l'utilise dans notre fonction ici.Et on va l'utiliser plusieurs fois.Et on va voir ce qu'il se passe.
00:11:26 :On va attendre 5 secondes.Et on est revenu à 1.On voit bien mon écran derrière.Excusez-moi, parce que j'ai zoomé.Mais je n'ai pas encore accès avec VS Code.
00:11:40 :Est-ce que c'est assez visible ?Oui, c'est bon.Oui, ok.Je suis avec PageShare habituellement.Maintenant, je suis avec VS Code.Donc, ça change un petit peu.
00:11:47 :Donc là, en fait, notre variable, elle aurait dû être à 5.Puisqu'en fait, ici, on appelle 5 fois, en fait, incrementer sans lock.Et le problème, c'est qu'en gros, à chaque fois,ils vont tous écrire du 0 plus 1 à ce niveau-là.
00:12:05 :Et du coup, en fait, ils ne vont pas arriver à 5.Donc, on peut avoir un comportement inattendu ici.Et c'est que là, j'ai un message.
00:12:14 :Vous pouvez m'enlever.On ne peut pas faire le join.Après, non, je n'ai pas essayé.Mais ça ne me paraîtrait pas possible.Puisqu'il faut que tu démarres tout.
00:12:29 :Et maintenant, parce qu'en fait, tu aurais ton join.À chaque fois, tu aurais le start join.Il faut vraiment que tous tes starts soient démarrés.
00:12:36 :Et après, que tu aies ton join vraiment tout en dernier.Je revérifierais, mais oui, ça me paraît logique.Pour moi, si, si, faire son join à la fin.
00:12:49 :D'abord, tous les starts, et après, tes joins.D'abord, tes 5 heures du frigo pour faire tout l'omelette.Oui, il faut démarrer tous les moteurs.Des fois, j'aime bien ces petits exemples comme ça.
00:13:02 :Du coup, là, on aurait bien un compteur qui aurait dû être égal à 5puisqu'à chaque fois, on est censé l'incrémenter.Et, on a ce comportement inattendu avec Python.
00:13:15 :Donc, ce qu'on peut faire, là, on va modifier ça.J'aurais dû l'appeler autrement parce que du coup, le surnommer, c'est chiant.Alors, attendez.Juste ça, modifier.
00:13:30 :Ouais, c'est bon.Donc là, on va faire autrement.Je vais faire un hint.Donc, on va avoir un traitement long.Ensuite, on va avoir, je vais réécrire ce qu'il faut.
00:13:47 :On va toujours bouger.Je vais avoir mon opération qui est un peu longue ici.On va simuler une opération longue.Ah, il y a quelqu'un qui arrive.
00:13:58 :C'est bon.Salut, Sylla. Je ne sais pas s'il m'entend.Est-ce qu'il a réussi à rejoindre Sylla ? Je ne vois pas.Est-ce qu'il est bien dans la session ?
00:14:16 :Sylla, Sylla.Bizarre.Peut-être qu'il a un petit problème de réseau.Ah, c'est bon.Salut, Sylla.Hop, donc on est sur le module threading.Ouais, Sylla.
00:14:38 :Donc là, je repars dessus.Ici, on va faire en sorte pour que ma variable compteur,elle aurait dû être égale à 5, mais elle ne l'est pasparce qu'on a vu que tous les threads,ils faisaient un peu la concurrence et ils me faisaient tous un 0 plus 1.
00:14:59 :Ça me faisait un comportement inattendu, donc ça ne va pas.Et pour ça, en fait, ce qu'il faut, c'est que du coup,ici, on va utiliser un context manager et on va utiliser lock.
00:15:15 :Et donc, ce qu'on va faire, c'est qu'on va passer en paramètres iciet on va faire with lock.Tac.Et là, ici, on va voir comment ça fonctionne.
00:15:33 :Lock va être égal à threading.lock.Et du coup, on va avoir ici un args cap qui va être lock.Et normalement, je n'ai rien d'autre à modifierà part ma faute d'orthographe que j'ai depuis le début ici.
00:15:56 :Et logiquement, si j'ai bien fait les choses,on va voir qu'ici, avec lock,ça permet d'éviter les erreurs de concurrence.Je vais chercher un peu de mots pour le dire.
00:16:09 :Ça va permettre d'éviter les erreurs de concurrenceet donc qu'à chaque fois, ils font tous un 0 plus 1et que du coup, le compteur revienne à 1.
00:16:18 :Là, normalement, on va être bien à 1, 2, 3, 4 et 5.Si il lance, on va voir.Donc là, il me lance bientôt en même temps.
00:16:31 :On est bien à 5. Hop, terminé.Et donc là, je suis bien à 5.Donc, c'est important comme ça, quand vous avez un peu une variableou un élément comme ça que vous avez besoin d'utiliser un lockpour éviter tous les comportements inattendus,c'est vraiment bien de le lock ici.
00:16:51 :C'est même obligatoire, vous n'avez pas le choix.Sinon, vos slides vont se faire concurrenceet à la fin, ça vous donne un résultat que vous n'allez pas comprendre.
00:17:01 :Donc voilà. Est-ce que pour ça, ça va ou pas ?Ok.Donc du coup, ce que je voulais dire, c'est que ça, c'est très bienquand on a des opérations longues comme ça.
00:17:21 :Une manque du temps, mais des opérations, voilà,chercher I.O. des entrées, des inputs, des opérations,des opérations entrées-sorties, par exemple, des opérations sur réseau.Il y a un message.
00:17:38 :Les locks.Je n'ai pas compris la question, je me suis fait retirer en priorité.Excuse-moi, j'ai mal compris ta question.Ah, ok.Mais en fait, en gros, le lock ici, c'est que,ça va empêcher que les différents slides que tu as créés,ici j'en ai cinq.
00:18:04 :Sinon, en fait, sans le lock, ils vont tous se faire concurrence.En fait, ils vont tous un peu l'exécuter en même temps.Alors du coup, tu vas avoir un comportement un peu bizarre.
00:18:12 :En fait, ça te permet vraiment ici,ils vont vraiment le faire en gros chacun leur tour.Pour vulgariser la chose.Ils vont vraiment le faire chacun leur tour et du coup,tu leur as bien une fois un, après une fois deux,après une fois trois, après une fois quatre, après une fois cinq.
00:18:30 :C'est comme un jeton en fait,qui tourne en fonction des appels de l'incrémentation.En fait, il porte bien son nom.C'est le lock qui le bloque.
00:18:45 :Et entre chaque appel, ça va être successif.Ils ne vont pas tous se faire concurrence dessus.Ils vont chacun attendre en fait.En fait, si je peux me permettre, si tu veux,dans la précédente version que Gams a présentée sans le lock,si tu veux, ils vont tous plus ou moins se jeter en même temps
00:19:05 :comme des requins sur compteur.Ils vont tous prendre la valeur de compteur actuelle.Donc là, elle est zéro.Sauf que eux, ils la mettent dans la variable current.
00:19:13 :Donc après, ce qui se passe pour la valeur compteur pour chaque thread,ils ne regardent pas réellement.Et après, s'ils font leur current plus 1,comme eux, ils l'ont mis à zéro, ils l'ont mis à 1.
00:19:24 :Donc, ils transforment le compteur à 1.Ce qui fait que comme ils se sont tous jetés comme des requins au début sur le compteuret que le compteur était à zéro,à la suite des décourses,eux, ils renvoient tous le compteur à 1.
00:19:34 :Là, avec lock, lock, il va dire,pas tout le monde en même temps.Toi, d'abord, tu prends compteur.Ok, tu le traites, tu renvoies la valeur.
00:19:41 :Et quand le deuxième arrive, il lui dit, tiens, regarde, la valeur de compteur,maintenant, c'est ça.Maintenant, tu la traites avec cette valeur.Et ainsi de suite, et ainsi de suite.
00:19:47 :Et ça permet une synchronisation, en fait.Voilà.Ça évite que tout le monde se jette, comme dirait Raffia,sur la valeur d'origineet chacun s'entoure comme un confesse.
00:19:58 :Et je n'ai pas vu la question.Pourquoi on n'a pas dans le cas précédent ?Ben oui, c'est exactement ça, du coup.Ben du coup, si on n'a pas eu besoin, c'est justement ce qui a posé le problème.
00:20:06 :C'est que, ben ouais, c'est bien dit.Oui, voilà, ils vont tous se jeter en même temps, quoi.C'est tout une concurrence.Ouais, c'est le mot, c'est vraiment, ils se font concurrence, en fait.
00:20:14 :Je crois que c'est le mot qui est souvent utilisé pour expliquer ça, d'ailleurs.C'est vraiment une concurrence qu'il y a entre tes threads.Que là, ici, ben, tu as bien fait ton lock.
00:20:23 :Alors, j'aurais peut-être pu mettre directement un withthreadings.lock.Ça aurait été plus parlant.Du coup, je disais...Qu'est-ce que je disais ?Voilà.Donc, je parlais du coup des opérations entre les sorties,donc opérations de réseau, comme ça.
00:20:40 :C'est super efficace.Après, je ne vais pas spoiler parce qu'il y a ici notre bibliothèque à Saint-Chiot.Bientôt, il y aura une présentation.Je ne spoil pas.
00:20:52 :Donc, je ne vais pas en parler ici à Saint-Chiot.On va rester sur threading et multiprocessing.Mais, en gros, threading, pour tout ce qui est entre sorties,donc par exemple, opérations réseau, pas de problème.
00:21:06 :Ça fonctionne bien.Là où threading va avoir des limites, c'est même sûr,c'est quand on va l'utiliser, par exemple, avec des fonctions CPU intensives.Donc, vraiment avec des calculs lourds.
00:21:20 :Je vais vous montrer ça.On va avoir, par exemple...Je prends trop mon temps là.J'espère que vous avez encore un peu de temps.On n'a pas tout à fait fini.
00:21:29 :On va avoir, par exemple, une fonction.On va l'appeler calcul somme carré.Elle va être toute bête.On va voir.Comment on va faire ça ?
00:21:49 :Allez, on va envoyer un calcul bien lourd.Est-ce que j'abuse ou je n'abuse pas du coup ?Allez, on va remettre 3-0.Tout dépend comment tu veux tester ta puce M1.
00:22:05 :Oui, je pensais exactement à 100 puces.On va mettre un puce égal et on va faire un i.J'ai encore du mal avec mes touches mathématiques.
00:22:19 :Donc là, on va mettre un petit espace qui sera plus propre.Donc là, il y a une opération où il va y avoir un peu de calcul.
00:22:29 :On va retourner le total.Le log, je ne vais plus m'en servir.Mon calcul de somme carré, c'est bon.Je vais pouvoir envoyer dans mes threads.
00:22:47 :Où est-ce que ça va le faire ?Alors attendez, comment j'ai fait mes threads ici ?Excusez-moi.Je vais peut-être appeler ma version threading maintenant.
00:23:03 :Non, je vais faire comme ça.Ce sera mieux.Je ne sais pas comment je vais le faire.On va avoir du coup notre version en multi-threading.
00:23:16 :Je n'ai pas l'expression en anglais, comme vous pouvez le voir.On va avoir ici notre liste.On repart.On va faire un range.On va peut-être se calmer avec 4.
00:23:31 :C'est déjà pas mal.Là, on va partir sur un threading.thread.On va avoir ici notre calcul.Somme carré.Et on va faire un append.J'ai eu l'alerte.
00:23:56 :Si la présentation se coupe, c'est que le VMI n'a pas supporté.Oui.Tu m'étonnes.J'ai envie de m'amuser.On va perdre le record de la session.
00:24:11 :Attention, on va bien voir.On arrive sur la fin de la fonction.J'ai encore des choses à vous montrer.Pour bien comparer les choses, on va faire une version séquentielle.
00:24:26 :J'ai mon casque qui tombe.On va faire la version séquentielle.Là, ça va être du basique.On va faire une range.On avait dit 4 à la première.
00:24:42 :Oui, j'avais mis 4 à ça.Et là, on va faire un calcul.Somme carré.Et on va faire une petite comparaison des performances.J'ai fait une faute.
00:24:53 :Je n'ai pas fait gaffe où.Dans ton underscore.Merci.Super.Là, j'ai bien les deux fonctions.Et maintenant, on va faire un start.Time.J'ai importé time.
00:25:07 :C'est bon.Time.time.Ici, on va faire une version multisquadring.Ensuite, on va faire un print.Et là, on va mettre le temps avec le multi.
00:25:23 :Je raccourcis un peu.Avec le multi.On va utiliser du coup.Je ne sais où.Je commence à m'y perdre.Je commence à m'y perdre.
00:25:37 :Time.time.J'ai mon start time.C'est ça.Seconde.Et ensuite, je peux faire du coup.On va voir la comparaison avec la version.La version séquentielle du coup.
00:26:04 :Ici.On va appeler notre version séquentielle.J'ai bien multisquadring.Et ici.On va lancer ça.On va bien voir.C'est parti.C'était une bonne soirée.
00:26:29 :Merci.J'espère que je n'ai pas fait d'erreur.OK.Vous voyez, le temps ici, il n'y a quasiment aucune différence.En fait, c'est normal, quand vous utilisez threading,quand vous faites des calculs CPU comme ça,c'est quasiment inutile d'utiliser threading.
00:26:54 :Annulé.Pourquoi il se met en route ?Attendez, il y a Cyril qui se met en route là.Stop.OK.Génial.Ce n'est pas grave.
00:27:07 :Pourquoi c'est mis en route ?Oui.Donc, que je disais, vous voyez que le temps,en fait, ici, il n'y a quasiment aucune différence.Et donc, calcul CPU intense.
00:27:19 :Et donc, ici, ce n'est pas efficace.On a dit que threading, c'était utile pour des opérationsd'entrée-sortie, par exemple, des opérations de réseau,ou d'écriture.
00:27:29 :Mais là, calcul comme ça, c'est un peu inutile.Du coup, c'est de là, et je pense qu'on va pouvoirterminer là-dessus, on va utiliser autre chosequi s'appelle, pas threading, mais multiprocessing.
00:27:48 :Et en fait, avec multiprocessing, avec threading,vous avez en fait tous les threads qui vont partagerle, je dis le GIL, c'est plus rapide,vous me comprenez, le GIL, le GIL.
00:28:00 :Donc, avec threading, ils vont tous se partager le GIL,ils vont se le passer, en fait, quand il faut.Mais en fait, avec multiprocessing, vous allez créerquatre processus, enfin là, j'ai mis un range 4,donc, oui, c'est ça.
00:28:12 :Donc, quatre processus indépendants.Et donc, en fait, ils vont chacun avoir leur GIL.Donc, ça va me demander de revoir un peu ma fonction.On ne va pas mettre T parce qu'on va se perdre.
00:28:27 :On va l'appeler, c'est multiprocessing,multiprocessing.process.Donc, ça marche quasiment pareil.On va taper ici, je vais l'appeler processus,hop, processus.happened.On va appeler, voilà, on va faire,donc c'est pareil, on va faire un start.
00:28:58 :Ici, on va utiliser P dans,on n'avait plus la liste, elle est où, processus?Processus.Donc, on va utiliser P.join.J'ai la version séquentielle.J'avais modifié quoi?
00:29:18 :Ok, ok, la version séquentielle est là.Et alors, il y a une chose qu'il faut penser à utiliseravec le, je me suis fait avoir il n'y a pas longtemps,multiprocessing.
00:29:30 :Ici, il est où?Multiprocessing, voilà.Si je lance comme ça, en fait, ça va planter.Il faut utiliser le fameux ifnameégal main.Hop, ici.
00:29:50 :Et donc, on va comparer, c'est pareil,les performances.Il faut que j'indente, tac.Je pense que je suis bon, je n'ai pas fait des erreurs de code.
00:30:01 :On te pose la question de savoir pourquoi il faut utiliserle ifname égal main.Bah, c'est, en fait, Python, tiens, regarde,je vais tenter, on va voir s'il va me le lancer,mais il va refuser, normalement.
00:30:16 :Il fait un prix, ouais, j'ai un petit prix support ici.Excusez-moi.Enfin, toi, il demande le, c'est Python qui te demandede le faire, en fait.
00:30:31 :Et si je le fais, tu vas voir, là, normalement,je n'aurai plus de message d'erreur.Hop.Et voilà.Moi aussi, j'ai trouvé ça bizarre.Je ne sais pas, il y a peut-être une sécurité.
00:30:47 :Je ne me suis pas posé la question, à vrai dire, en fait.C'est vrai que ce n'est pas très bien, mais si tu ne le mets pas,en fait, tu t'envoies un gros message d'erreur.
00:30:56 :Du coup, là, on voit que tout à l'heure,on n'avait aucune différence.Est-ce que là, vous voyez bien mon terminal ?Le plan d'exécution, on en a un.
00:31:09 :Donc, avec le multi, on est à 0.53.En séquentiel, on est à 1.79.Donc, là, on a un vrai gain de temps.Donc, gros calcul comme ça, il faut utiliser,pas threading, mais multiprocessing.
00:31:23 :Est-ce que, pour vous, c'est bon, ça ou pas ?Ouais, là, j'étais beaucoup plus rapide.OK.Donc, là, je reviens, vite fait.En gros, donc, Python avec le GIL,on va exécuter les choses de manière séquentielle,l'une après l'autre.
00:31:43 :Donc, là, on a voulu avoir du parallélisme.On a utilisé threading.Donc, ici, les threads,ils vont se partager le GIL intelligemment.Il faut bien penser à utiliser un lockpour, par exemple, une variable partagée.
00:32:02 :Ensuite, quand on a des gros calculs CPU,ici, threading, ça ne va vous servir à rien.Il faut multiprocessing et, en fait,ici, il n'y aura pas un GIL,mais chaque processus, ils vont tous être séparés.
00:32:13 :Ils vont être gérés par votre PC différemment.Ils vont chacun avoir leur GIL.Voilà.Alors, la question que je me suis posée,c'est aussi, par exemple,pourquoi on n'utiliserait pas tout le temps multiprocessing ?
00:32:25 :Parce que, du coup, si ça fait tout...En fait, non.Il faut avoir un niveau pratique.En fait, multiprocessing peut éviter de consommer plus de mémoire.
00:32:32 :Donc, utiliser threading pour tout ce qui est entrée et sortieet multiprocessing quand c'est du calcul CPU.Et donc, pour faire le parallèle à threading,tu auras une présentation plus tard.
00:32:50 :Je l'annonce normalement par Stéphane.J'ai le droit, Stéphane, je t'annonce.Tu as tous les droits.Qui nous fera une présentation sur Asyncioet qui va faire un peu le parallèle avec ce que je vous ai parlé.
00:33:07 :En gros, pour résumer, Asyncio, c'est un seul thread.Donc, c'est plus performant.Sauf qu'il y a des librairies qui ne sont pas forcément compatibles.Et donc, c'est pareil.
00:33:18 :C'est assez efficace avec tout ce qui est tâche,comme on disait avec threading,tâche entrée et sortie avec le réseau.Donc, avec threading, en fait, c'est plus votre OSqui va gérer un peu les changements de thread.
00:33:31 :Et en fait, avec Asyncio, c'est plus le développeur, en fait,qui lui, avec le mot-clé await,qui va dire quand est-ce que vous libérez les GILs.
00:33:43 :Mais c'est juste...J'en parle juste parce que tout de suite,j'ai parlé de threading et multiprocessing.J'ai précisé un petit peu, en fait,l'un des gros avantages d'Asyncio aussi,c'est qu'on peut mélanger plusieurs fonctions différentesqui n'ont pas forcément toutes la même chose dedans.
00:34:01 :Voilà.Donc, je n'en dis pas plus.Mais du coup, là, ce soir, c'était vraiment sur threading.A la base, ça va être que sur threading.
00:34:09 :Mais je me suis dit que c'était un peu bêtede ne pas parler de multiprocessingparce que du coup, ça va assez bien faire le parallèle entre les deux.
00:34:15 :Parce que si vous utilisez un threadingavec des gros calculs CPU, comme vous l'avez vu, ça ne sert à rien.Donc, je voulais absolument parler des deux.
00:34:22 :Je ne voulais pas parler de l'un sans l'autre.Et voilà.Et c'est tout ce que je voulais dire pour ce soir.Est-ce que ça paraît un peu plus clair pour vous ou pas ?
00:34:34 :Parce que je sais qu'en général,quand on commence le GIL, threading, multiprocessing,on se dit « mais à quoi l'un sert, à quoi l'autre va servir ? »
00:34:42 :Dites-moi, si ça a l'air clair, tant mieux.De toute façon, la diffusion va être disponible, comme d'hab,si vous avez besoin de revenir dessus.Mais en tout cas, c'est tout pour moi.
00:34:58 :Je ne sais pas si tu as des choses à rajouter.Comme je dis souvent, c'est le genre de concept pitonqu'il faut utiliser, tordre dans tous les senspour bien comprendre et bien le saisir.
00:35:10 :Oui, c'est clair.C'est clair.Mais déjà, là au moins, en plus pour ceux qui passent le ToSA,ça vous permet d'avoir un aperçu de qui fait quoi.
00:35:20 :Si on vous pose la question sur...Je ne sais plus si on avait eu, toi Stéphane, je ne sais pas si t'en as eu.Moi, perso, je ne comprends pas.
00:35:26 :Je n'ai pas eu de questions sur le threading de mémoire.Mais vu que c'est de la librairie de base,il n'y a pas de raison pour en avoir.
00:35:33 :Donc au moins, vous avez un aperçu de threading et multiprocessing.Et puis bientôt, à Saint-Chiot.Si c'est bon pour vous, tant mieux.Puis n'hésitez pas, même sous de mon voyant privé,des questions ou si vous avez des suggestions d'amélioration,si ça vous apparaît un peu compliqué ou pas assez clair,
00:35:53 :il n'y a aucun problème.Yes, allez-y, allez-y, parlez, parlez.Oui, juste une question.Si on développe une interface graphiqueet qu'on veut faire des animations depuis différentes sources,est-ce que cette technique de multithread, on peut l'utiliserou est-ce qu'il faut faire autre chose ?
00:36:19 :Je confirme qu'on peut l'utiliser.J'ai développé une app que Gab a vue il n'y a pas longtemps.Quand je fais référence, Gab, il y a une barre de progressionà un moment dans l'app.
00:36:32 :Et en fait, pour gérer la barre de progression,j'ai utilisé simplement du threading.D'accord, super, merci.Du coup, votre application,c'était sur quelle technologie d'interface graphique ?
00:36:48 :C'était sur du PyQt.D'accord, excellent, merci.Et Stéphane, tu avais bien utilisé du multithreading dessus, je ne sais plus.Oui, j'avais utilisé du multithreading.En fait, je lançais les tâches de mon applicationet en fait, à chaque fois que le thread,la tâche était terminée, il incrémentait le compteur d'approvation.
00:37:14 :Oui, ok, donc c'était bien avec la librairie threading, du coup.Voilà, c'est ça.Je ne savais plus si au niveau graphique, c'était ok.Donc c'était bien avec ça que tu l'avais fait.
00:37:25 :Oui, j'ai regardé ta présentation.Ok, merci du coup.C'est bon, on a un retour d'expérience comme ça.Silas, tu avais une question aussi, je crois.
00:37:34 :Oui, allô Gab, merci.Je suis un peu venu en retard.Bon, je voulais savoir si tu peuxla définition du threading et du multiprocessing.En fait, la définition est là que tu l'utilises.
00:37:49 :Ok, ok, je vais revenir dessus si tu veux rapidement.En gros, de toute façon, je vais faire un,comment ça s'appelle, un repo aussi,pour que ce soit plus clair.
00:38:00 :En gros, on parlait donc du GIL en Python,donc on va avoir en gros tout qui va s'exécuter de manière séquentielle.On va avoir un thread, donc ça va s'exécuter de manière séquentielle.
00:38:15 :Et on s'est dit, on partait d'une fonction à la base,si tu veux, je les ai copies normalement sur la mesure.Bon, je t'explique.On partait en fait d'une fonction à la basequi prenait avec un time.sleep de 3 secondes.
00:38:29 :On appelait la fonction en gros l'une après l'autre,donc forcément en séquentielle ça prend 6 secondes.Donc, on a utilisé la livrairie qui est threading, tu vois.
00:38:44 :Et avec threading, en fait, ça nous a permis d'exécuter en parallèlel'appel de ces deux fonctions.En gros, au lieu de prendre 6 secondes, on l'appelait deux fois,mais ça n'a pris que 3 secondes.
00:38:57 :Donc, threading c'est bien pour ce genre de choses.Par contre, dès que tu as des calculs vraiment de CPU,threading c'est plus efficace.C'est là qu'il faut utiliser mieux, comme je disais tout à l'heure,le multiprocessing.
00:39:12 :Voilà.Donc, calcul CPU, multiprocessing.Voilà.C'est ce qu'il faut que tu te dises.Si tu as les instructions côté processeur,c'est mieux utiliser le multiprocessing.
00:39:25 :Ouais, par exemple, exemple tout bête,on s'est demandé si mon PC allait être content,ça avait pas mal pris.Des calculs comme ça, tu utilises le multiprocessing.
00:39:39 :Tout ce qui est calcul CPU.Parce que threading, il ne va pas gérer ça.On a fait le test, il n'y avait pas d'écart au niveau des secondes.
00:39:47 :On était à 1.79 et 1.83, je crois, pour l'un ou pour l'autre.Ici, en multi, on est bien à 0.53 et 1.79.En fait, avec multiprocessing,ce n'est pas chaque thread,ça va découper en plusieurs processuset chacun va avoir leur gil.
00:40:03 :Voilà.En fait, là, si tu veux, si tu connais biencomment on fait les processeurs modernes,en fait, plusieurs threads dans un processeur, d'accord ?
00:40:14 :Ouais, ouais.Donc, threading porte assez mal son nom, en fait,puisqu'il ne va pas réellement utiliser plusieurs threads du processeurpour faire ses calculs.Il va toujours utiliser un seul threadcomme le fait ping-pong dans 99% de ses actes.
00:40:28 :La seule chose qu'il va faire avec threading,c'est qu'il va, lui, gérer les accès de chaque processusaux threads qui ont été bloqués par le gil, d'accord ?
00:40:38 :D'accord.Lorsque tu passes en multiprocessing,là, on arrive réellement à utiliser plusieurs threads,ce qui explique d'ailleurs la différence de temps qu'on a pu observer.
00:40:48 :C'est-à-dire que là, il va vraiment créer des processus à partqui vont chacun utiliser un thread du processeur.Ce qui fait que là, on a pu observer clairement,comme Gab avait lancé dans son version multithreading 4 processus,du coup, le temps a été divisé par 4puisque chaque processus a vraiment utilisé un thread du processeur.
00:41:09 :D'accord.Donc, c'est un peu...Je ne sais pas si le concept de async-await,bon, je ne sais pas si c'est la même chose.Ce n'est pas tout à fait la même chose.
00:41:21 :On en reparlera.Oui, Stéphane fera une présentation spéciale sur ça.D'accord.En gros, dis-toi que vraiment threading,on va voir, ils vont se partager le GIL,que multiprocessing, il n'y a pas de partage de GIL,c'est chacun leur GIL.
00:41:40 :Ok, passé le concept, par exemple,parce que moi, je fais beaucoup de .NET,si tu dis une fonction async,il y a le thread pool,comme on dit le thread,et c'est le conteneur du thread.
00:41:57 :Donc, quand tu envoies une instruction,ça dépend du processeur,si c'est encore neuf, ça dépend du processeur.Donc, en fonction du processeur,il va t'alluer le thread.
00:42:08 :Mais si c'est un async,genre, il te donne le thread,il le récupère,il ne met pas en train de donner ta requête,et si il y a une nouvelle requête,il peut utiliser le même thread pour têter ta requête.
00:42:23 :Oui, avec Async, il utilise un seul thread.Oui, le même thread peut têter plusieurs requêtes.Oui, avec Async, c'est ça.Oui, avec Async.Je m'y suis pensé avec ça, mais je pense...
00:42:37 :Et ça sera proche du fonctionnementque tu vas observer avec threading.D'accord.Après, threading, moi j'aime bien,mais c'est vrai qu'avec Async,tu es plus précis dans ce que tu veux faire,avec justement le await.
00:42:54 :Oui, effectivement.Je ne connais pas le concept de Async,et je ne connais pas beaucoup un Python.Je n'irai jamais dedans.Ce n'est pas si sorcier que ça.
00:43:06 :Tu t'y mets une fois dedans,tu vas voir.C'est assez simple.Je trouve que plus chiant,c'était la première foisque j'en ai eu à en parler,c'était multiprocessing.
00:43:20 :Je ne savais pas pourquoi ils avaient misun threading multiprocessing,deux différents comme ça.On a parlé pourquoi c'était différentet pourquoi il y avait un multiprocessing.
00:43:30 :Mais après, une fois que tu arrivesà distinguer threading, multiprocessingà 5, après, franchement, ça va.D'accord, merci. Je vois bien.Pour essayer de simplifier,tu vas essayer threading.
00:43:42 :Tu as plusieurs tâches,par exemple, que toutes les tâchesque tu avais mises dans tes threadingsont bien toutes été réalisées.Parce que là, tu as besoin que,par exemple, toutes tes tâches soientréalisées pour pouvoir passer à la suite.
00:43:56 :Avec multiprocessing, là, tu vas lancerplusieurs tâches, et là, quelque part,l'intérêt, le principal intérêt,ce n'est pas tellement de savoirsi toutes les tâches ont été utiliséeset toutes terminées en même temps,mais bien qu'elles s'exécutentchacune dans un thread différent.
00:44:12 :Donc, elles s'exécutent le plus rapidement possibleen répartissant la tâche sur plusieurs threads du processeur.OK. Chaque tâche a son thread.C'est ça.Ouais.Là, ils vont à leur gil.
00:44:24 :Je vais faire un repo, de toute façon.Il y aura tous les exemples que j'ai mis.Il y en a même un où je n'en ai pas parlé,mais c'est avec Asyncio,mais c'était juste pour voir la différence.
00:44:34 :Sinon, je vais faire un repo.Je vous l'envoie, après,je vais le faire là.OK. Merci.Je viens de voir ta question, Gico.Ah, je n'ai pas vu.
00:44:46 :Je me suis demandé si on pouvait combinermultiprocessing et threading.Là, comme ça ?Ça me paraît un peu dangereux.Là, comme ça,je ne me risquerais pas.
00:44:58 :Après, il y a des sécurités en Python,mais je ne vois pasdans quelle...Je ne vois pas comment le codes'interdirait.Tu risques de te retrouverdans une usine à gaztrès compliquée à gérer.
00:45:14 :Mais nous aussi.En fait, je ne vois paspourquoi on pourrait faire ça.Utiliser l'un selon les tâchesque l'on va faire.Si c'est de l'IO, si c'est du CPU.
Aucune occurrence trouvée pour « ».
