{"id":7899,"date":"2019-01-10T00:00:00","date_gmt":"2019-01-09T23:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7899"},"modified":"2024-08-30T11:39:06","modified_gmt":"2024-08-30T09:39:06","slug":"ecrire-une-thread-pool-en-ruby","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby","title":{"rendered":"\u00c9crire une thread pool en Ruby"},"content":{"rendered":"<p><em>Article \u00e9crit par Hugo Fabre<\/em><\/p>\n<p>Pouvoir ex\u00e9cuter plusieurs t\u00e2ches en parall\u00e8le, que ce soit dans un script ou une application, peut \u00eatre vraiment tr\u00e8s utile, surtout dans le cas o\u00f9 le traitement de ces t\u00e2ches peut \u00eatre tr\u00e8s long. Pour pallier ce probl\u00e8me, la plupart des langages de programmation nous offrent plusieurs solutions. Dans notre cas, nous utiliserons des <em>threads<\/em>. Pour ceux qui ne sont pas familiers avec l\u2019utilisation des <em>threads<\/em> en Ruby, je vous invite \u00e0 regarder cette vid\u00e9o qui traite du sujet.<\/p>\n<h2 id=\"pourquoi-une-thread-pool-\">Pourquoi une <em>thread pool<\/em> ?<\/h2>\n<blockquote><p>Pourquoi utiliser une <em>thread pool<\/em> alors qu\u2019on pourrait juste g\u00e9n\u00e9rer un nouveau thread pour chaque t\u00e2che\u00a0?<\/p><\/blockquote>\n<p>Effectivement, on pourrait se contenter de lancer un <em>thread<\/em> par t\u00e2che et d\u2019attendre le r\u00e9sultat. Le souci avec cette approche c\u2019est que si vous avez beaucoup de t\u00e2ches \u00e0 effectuer, vous allez surcharger votre machine qui a de grandes chances de planter.<\/p>\n<h2 id=\"cest-parti\">C\u2019est parti\u00a0!<\/h2>\n<p>Avant toute chose, si vous rencontrez des <code>can't alloc thread (ThreadError)<\/code> en utilisant Ruby 2.5.0, je vous conseille d\u2019utiliser la version 2.4.2, 2.5.3, ou 2.6.0. Je suppose que le probl\u00e8me est li\u00e9 \u00e0 ce <a href=\"https:\/\/bugs.ruby-lang.org\/issues\/14171\">bug<\/a><\/p>\n<h3 id=\"les-tches--effectuer\">Les t\u00e2ches \u00e0 effectuer<\/h3>\n<p>Nous allons d\u2019abord \u00e9crire une classe qui repr\u00e9sentera les diff\u00e9rentes t\u00e2ches \u00e0 ex\u00e9cuter via nos <em>threads<\/em>.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">LongTask<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"n\">value<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@value<\/span> <span class=\"o\">=<\/span> <span class=\"n\">value<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">run<\/span>     <span class=\"nb\">sleep<\/span><span class=\"p\">(<\/span><span class=\"mi\">10<\/span><span class=\"p\">)<\/span>     <span class=\"nb\">print<\/span> <span class=\"s2\">\"<\/span><span class=\"si\">#{<\/span><span class=\"vi\">@value<\/span><span class=\"si\">}<\/span><span class=\"se\">n<\/span><span class=\"s2\">\"<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>C\u2019est une t\u00e2che tr\u00e8s simple, mais gr\u00e2ce \u00e0 l\u2019utilisation de <code>sleep(10)<\/code>, on s\u2019assure qu\u2019elle prendra au moins 10 secondes \u00e0 s\u2019ex\u00e9cuter ce qui nous permettra de mieux visualiser le fonctionnement de notre <em>thread pool<\/em>.<\/p>\n<p>Pour tester, vous pouvez d\u00e9j\u00e0 lancer quelques t\u00e2ches\u00a0:<\/p>\n<p>En synchrone\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"mi\">5<\/span><span class=\"p\">.<\/span><span class=\"nf\">times<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">i<\/span><span class=\"o\">|<\/span>   <span class=\"no\">LongTask<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">i<\/span><span class=\"p\">).<\/span><span class=\"nf\">run<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>En asynchrone\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">tasks<\/span> <span class=\"o\">=<\/span> <span class=\"p\">[]<\/span> <span class=\"n\">threads<\/span> <span class=\"o\">=<\/span> <span class=\"p\">[]<\/span>  <span class=\"mi\">5<\/span><span class=\"p\">.<\/span><span class=\"nf\">times<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">i<\/span><span class=\"o\">|<\/span>   <span class=\"n\">tasks<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"no\">LongTask<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">i<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span>  <span class=\"n\">tasks<\/span><span class=\"p\">.<\/span><span class=\"nf\">each<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">task<\/span><span class=\"o\">|<\/span>   <span class=\"n\">threads<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"no\">Thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"k\">do<\/span>     <span class=\"n\">task<\/span><span class=\"p\">.<\/span><span class=\"nf\">run<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span>  <span class=\"n\">threads<\/span><span class=\"p\">.<\/span><span class=\"nf\">each<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:join<\/span><span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Comme vous avez pu le remarquer si vous avez test\u00e9 les deux fa\u00e7ons de faire pr\u00e9sent\u00e9es ci-dessus, lorsqu\u2019on lance les t\u00e2ches dans des <em>threads<\/em> on ne sait pas dans quel ordre elles seront ex\u00e9cut\u00e9es, il faudra \u00eatre conscient de \u00e7a dans l\u2019utilisation de notre <em>thread pool<\/em>.<\/p>\n<h3 id=\"la-thread-pool\">La <em>thread pool<\/em><\/h3>\n<p>Pour notre <em>thread pool<\/em> nous aurons besoin d\u2019un tableau pour stocker les <em>threads<\/em> en cours d\u2019ex\u00e9cution, d\u2019une <a href=\"https:\/\/fr.wikipedia.org\/wiki\/File_(structure_de_donn%C3%A9es)\">file<\/a> pour stocker les t\u00e2ches en attentes et enfin d\u2019une taille maximum, qui nous permettra justement d\u2019\u00e9viter les probl\u00e8mes qu\u2019on pourrait causer en g\u00e9n\u00e9rant trop de <em>threads<\/em> en m\u00eame temps. Je vous propose une impl\u00e9mentation tr\u00e8s simple pour commencer\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">ThreadPool<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"ss\">size: <\/span><span class=\"mi\">10<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@size<\/span> <span class=\"o\">=<\/span> <span class=\"n\">size<\/span>     <span class=\"vi\">@tasks<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Queue<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span>     <span class=\"vi\">@pool<\/span> <span class=\"o\">=<\/span> <span class=\"p\">[]<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">schedule<\/span><span class=\"p\">(<\/span><span class=\"o\">*<\/span><span class=\"n\">args<\/span><span class=\"p\">,<\/span> <span class=\"o\">&amp;<\/span><span class=\"n\">block<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@tasks<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"p\">[<\/span><span class=\"n\">block<\/span><span class=\"p\">,<\/span> <span class=\"n\">args<\/span><span class=\"p\">]<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<blockquote><p>Effectivement c\u2019est simple, mais comment on l\u2019utilise\u00a0?<\/p><\/blockquote>\n<p>Nous allons avoir besoin d\u2019une m\u00e9thode pour d\u00e9marrer notre <em>thread pool<\/em>. Mais avant de la coder, il faut savoir ce qu\u2019on va y faire. Donc l\u2019objectif de notre classe sera d\u2019attendre en continu la pr\u00e9sence d\u2019une ou plusieurs t\u00e2ches dans la file puis de les d\u00e9piler pour les ex\u00e9cuter une par une dans des <em>threads<\/em> s\u00e9par\u00e9s dans la limite du nombre de <em>threads<\/em> disponibles\u2122. Chaque <em>thread<\/em> aura la charge de s\u2019enlever de notre <em>thread pool<\/em> une fois son traitement termin\u00e9.<\/p>\n<blockquote><p>Facile\u00a0!<\/p><\/blockquote>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">ThreadPool<\/span>   <span class=\"c1\"># ...<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">start<\/span>     <span class=\"no\">Thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"k\">do<\/span>       <span class=\"kp\">loop<\/span> <span class=\"k\">do<\/span>         <span class=\"k\">next<\/span> <span class=\"k\">if<\/span> <span class=\"vi\">@pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">size<\/span> <span class=\"o\">&gt;=<\/span> <span class=\"vi\">@size<\/span>          <span class=\"n\">task<\/span><span class=\"p\">,<\/span> <span class=\"n\">args<\/span> <span class=\"o\">=<\/span> <span class=\"vi\">@tasks<\/span><span class=\"p\">.<\/span><span class=\"nf\">pop<\/span>         <span class=\"n\">thread<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"k\">do<\/span>           <span class=\"n\">task<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"o\">*<\/span><span class=\"n\">args<\/span><span class=\"p\">)<\/span>           <span class=\"n\">end_thread<\/span><span class=\"p\">(<\/span><span class=\"n\">thread<\/span><span class=\"p\">)<\/span>         <span class=\"k\">end<\/span>         <span class=\"vi\">@pool<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"n\">thread<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">end_thread<\/span><span class=\"p\">(<\/span><span class=\"n\">thread<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">delete<\/span><span class=\"p\">(<\/span><span class=\"n\">thread<\/span><span class=\"p\">)<\/span>     <span class=\"n\">thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">kill<\/span>   <span class=\"k\">end<\/span>   <span class=\"c1\"># ...<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Attention, \u00e0 noter l\u2019encapsulation du travail de la m\u00e9thode dans un <em>thread<\/em>. Si on ne le fait pas notre m\u00e9thode devient bloquante et impossible d\u2019y ajouter des t\u00e2ches apr\u00e8s l\u2019avoir lanc\u00e9e. Et si on testait pour voir ?<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">thread_pool<\/span> <span class=\"o\">=<\/span> <span class=\"no\">ThreadPool<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">start<\/span>  <span class=\"mi\">15<\/span><span class=\"p\">.<\/span><span class=\"nf\">times<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">i<\/span><span class=\"o\">|<\/span>   <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">schedule<\/span> <span class=\"k\">do<\/span>     <span class=\"no\">LongTask<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">i<\/span><span class=\"p\">).<\/span><span class=\"nf\">run<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<blockquote><p>Eh bien ? Il ne se passe rien\u2026<\/p><\/blockquote>\n<p>Effectivement il ne se passe pas grand-chose, mais pourquoi ? Ici le souci c\u2019est que l\u2019on d\u00e9marre notre <em>thread pool<\/em> en asynchrone qui attend d\u2019avoir des t\u00e2ches pour les effectuer. Le probl\u00e8me c\u2019est que comme elle tourne en asynchrone, notre programme se termine avant qu\u2019elle ait fini de jouer toutes ses t\u00e2ches.<\/p>\n<p>Ici c\u2019est en fait un faux probl\u00e8me. Selon l\u2019utilisation que vous aurez de votre <em>thread pool<\/em> on pourrait tr\u00e8s bien s\u2019arr\u00eater ici. Par exemple, imaginons que j\u2019aie une application qui \u00e9coute via la <a href=\"https:\/\/github.com\/guard\/listen\">Gem listen<\/a> un dossier donn\u00e9, avec pour r\u00f4le de d\u00e9placer les fichiers entrants en suivant des r\u00e8gles sp\u00e9cifiques (dans des dossiers diff\u00e9rents selon leurs noms par exemple). Cette application sera destin\u00e9e \u00e0 tourner sans s\u2019arr\u00eater et du coup le probl\u00e8me n\u2019existe pas, puisqu\u2019on ne terminera jamais volontairement l\u2019application.<\/p>\n<p>Mais pour rendre les choses plus int\u00e9ressantes, je vous propose de moderniser un peu notre <em>thread pool<\/em>.<\/p>\n<h3 id=\"aller-plus-loin\">Aller plus loin<\/h3>\n<h4 id=\"attendre-que-la-thread-pool-nait-plus-de-tches--effectuer-pour-sarrter\">Attendre que la <em>thread pool<\/em> n\u2019ait plus de t\u00e2ches \u00e0 effectuer pour s\u2019arr\u00eater<\/h4>\n<p>Tr\u00e8s simple, il suffit de rajouter une m\u00e9thode pour savoir si notre <em>thread pool<\/em> est active\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">ThreadPool<\/span>   <span class=\"c1\"># ...<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">inactive<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span>     <span class=\"vi\">@tasks<\/span><span class=\"p\">.<\/span><span class=\"nf\">empty<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span> <span class=\"o\">&amp;&amp;<\/span> <span class=\"vi\">@pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">empty<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span>   <span class=\"k\">end<\/span>    <span class=\"c1\"># ...<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Et ensuite, on v\u00e9rifie r\u00e9guli\u00e8rement pour savoir si notre <em>thread pool<\/em> est toujours active, notre code de test devient donc\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">thread_pool<\/span> <span class=\"o\">=<\/span> <span class=\"no\">ThreadPool<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">start<\/span>  <span class=\"mi\">15<\/span><span class=\"p\">.<\/span><span class=\"nf\">times<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">i<\/span><span class=\"o\">|<\/span>   <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">schedule<\/span> <span class=\"k\">do<\/span>     <span class=\"no\">LongTask<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">i<\/span><span class=\"p\">).<\/span><span class=\"nf\">run<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span>  <span class=\"nb\">sleep<\/span><span class=\"p\">(<\/span><span class=\"mi\">1<\/span><span class=\"p\">)<\/span> <span class=\"k\">until<\/span> <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">inactive<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h4 id=\"gestion-derreur\">Gestion d\u2019erreur<\/h4>\n<p>Avec notre impl\u00e9mentation, il n\u2019est pas trop compliqu\u00e9 de g\u00e9rer et reporter les erreurs qui se produiraient lors du traitement d\u2019une t\u00e2che. Pour cela nous allons encapsuler chaque lancement de t\u00e2che et son <em>thread<\/em> associ\u00e9 dans un objet sp\u00e9cifique <code>Processor<\/code>. Cela nous permettra d\u2019identifier chaque t\u00e2che qui a \u00e9chou\u00e9 et pourquoi. Ce <code>Processor<\/code> aura connaissance de la t\u00e2che \u00e0 effectuer, les arguments \u00e0 lui passer, son status (r\u00e9ussi ou rat\u00e9), le <em>thread<\/em> dans lequel la t\u00e2che a \u00e9t\u00e9 lanc\u00e9, les \u00e9ventuels messages d\u2019erreur et enfin un <code>manager<\/code> qui est en fait notre <em>thread pool<\/em>. Nous en avons besoin pour pouvoir lui signifier qu\u2019un traitement est fini et le pr\u00e9venir en cas d\u2019erreur.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Processor<\/span>   <span class=\"nb\">attr_reader<\/span> <span class=\"ss\">:thread<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"n\">task<\/span><span class=\"p\">,<\/span> <span class=\"n\">args<\/span><span class=\"p\">,<\/span> <span class=\"n\">manager<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@task<\/span> <span class=\"o\">=<\/span> <span class=\"n\">task<\/span>     <span class=\"vi\">@args<\/span> <span class=\"o\">=<\/span> <span class=\"n\">args<\/span>     <span class=\"vi\">@manager<\/span> <span class=\"o\">=<\/span> <span class=\"n\">manager<\/span>     <span class=\"vi\">@success<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">false<\/span>     <span class=\"vi\">@thread<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span>     <span class=\"vi\">@error<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">run<\/span>     <span class=\"vi\">@thread<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"k\">do<\/span>       <span class=\"k\">begin<\/span>         <span class=\"vi\">@task<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"o\">*<\/span><span class=\"n\">args<\/span><span class=\"p\">)<\/span>         <span class=\"vi\">@success<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">true<\/span>       <span class=\"k\">rescue<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"n\">e<\/span>         <span class=\"vi\">@success<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">false<\/span>         <span class=\"vi\">@error<\/span> <span class=\"o\">=<\/span> <span class=\"n\">e<\/span><span class=\"p\">.<\/span><span class=\"nf\">message<\/span>         <span class=\"vi\">@manager<\/span><span class=\"p\">.<\/span><span class=\"nf\">add_failed_processor<\/span><span class=\"p\">(<\/span><span class=\"nb\">self<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>        <span class=\"vi\">@manager<\/span><span class=\"p\">.<\/span><span class=\"nf\">end_processor<\/span><span class=\"p\">(<\/span><span class=\"nb\">self<\/span><span class=\"p\">)<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">success<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span>     <span class=\"vi\">@success<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">fail<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span> <span class=\"err\">\u00a0<\/span><span class=\"o\">!<\/span><span class=\"n\">success<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ensuite on va devoir changer quelques petites choses dans notre <em>thread pool<\/em>. D\u2019abord, on va changer la m\u00e9thode <code>end_thread<\/code> qui deviendra <code>end_processor<\/code> vu que l\u2019on g\u00e8re maintenant des processeurs qui encapsulent nos <em>threads<\/em> et rajouter une m\u00e9thode pour stocker les processeurs qui ont rat\u00e9<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">ThreadPool<\/span>   <span class=\"c1\"># ...<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">end_processor<\/span><span class=\"p\">(<\/span><span class=\"n\">processor<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">delete<\/span><span class=\"p\">(<\/span><span class=\"n\">processor<\/span><span class=\"p\">)<\/span>     <span class=\"n\">processor<\/span><span class=\"p\">.<\/span><span class=\"nf\">thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">kill<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">add_failed_processor<\/span><span class=\"p\">(<\/span><span class=\"n\">processor<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@failed_processors<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"n\">processor<\/span>   <span class=\"k\">end<\/span>    <span class=\"c1\"># ...<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>On pense \u00e0 rajouter notre nouvelle variable d\u2019instance <code>@failed_processors = []<\/code> et ensuite on change l\u00e9g\u00e8rement notre m\u00e9thode <code>start<\/code> de la <em>thread pool<\/em>\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">ThreadPool<\/span>   <span class=\"c1\"># ...<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">start<\/span>     <span class=\"vi\">@waiting_thread<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Thread<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"k\">do<\/span>       <span class=\"kp\">loop<\/span> <span class=\"k\">do<\/span>         <span class=\"k\">next<\/span> <span class=\"k\">if<\/span> <span class=\"vi\">@pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">size<\/span> <span class=\"o\">&gt;=<\/span> <span class=\"vi\">@size<\/span>          <span class=\"n\">task<\/span><span class=\"p\">,<\/span> <span class=\"n\">args<\/span> <span class=\"o\">=<\/span> <span class=\"vi\">@tasks<\/span><span class=\"p\">.<\/span><span class=\"nf\">pop<\/span>         <span class=\"n\">processor<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Processor<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">task<\/span><span class=\"p\">,<\/span> <span class=\"n\">args<\/span><span class=\"p\">,<\/span> <span class=\"nb\">self<\/span><span class=\"p\">)<\/span>         <span class=\"n\">processor<\/span><span class=\"p\">.<\/span><span class=\"nf\">run<\/span>         <span class=\"vi\">@pool<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"n\">processor<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span>    <span class=\"c1\"># ...<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Nous sommes fin pr\u00eats pour lancer tout \u00e7a et avoir un petit reporting \u00e0 la fin. Il faudra quand m\u00eame rajouter un <code>attr_reader :failed_processors<\/code> \u00e0 notre <em>thread pool<\/em>.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">thread_pool<\/span> <span class=\"o\">=<\/span> <span class=\"no\">ThreadPool<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">start<\/span>  <span class=\"mi\">15<\/span><span class=\"p\">.<\/span><span class=\"nf\">times<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">i<\/span><span class=\"o\">|<\/span>   <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">schedule<\/span> <span class=\"k\">do<\/span>     <span class=\"no\">LongTask<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">i<\/span><span class=\"p\">).<\/span><span class=\"nf\">run<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span>  <span class=\"nb\">sleep<\/span><span class=\"p\">(<\/span><span class=\"mi\">1<\/span><span class=\"p\">)<\/span> <span class=\"k\">until<\/span> <span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">inactive<\/span><span class=\"err\">\u00a0<\/span><span class=\"p\">?<\/span> <span class=\"nb\">puts<\/span> <span class=\"s2\">\"Failed tasks\u00a0: <\/span><span class=\"si\">#{<\/span><span class=\"n\">thread_pool<\/span><span class=\"p\">.<\/span><span class=\"nf\">failed_processors<\/span><span class=\"si\">}<\/span><span class=\"s2\">\"<\/span>  <span class=\"c1\"># Results =&gt;<\/span> <span class=\"c1\"># ...<\/span> <span class=\"c1\"># 12<\/span> <span class=\"c1\"># 13<\/span> <span class=\"c1\"># 14<\/span> <span class=\"c1\"># Failed tasks\u00a0: []<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h2 id=\"cest-fini-\">C\u2019est fini !<\/h2>\n<p>\u00c9videmment il faut garder \u00e0 l\u2019esprit que c\u2019est un choix d\u2019impl\u00e9mentation parmi tant d\u2019autres, avec ses qualit\u00e9s et ses d\u00e9fauts. J\u2019ai choisi cette approche parce qu\u2019elle me permet d\u2019avoir quelque chose de simple et de tr\u00e8s facilement modulable, par exemple j\u2019ai pu rajouter un syst\u00e8me de <code>Timeout<\/code> sur mes processeurs ainsi qu\u2019un syst\u00e8me de <em>retry<\/em> limit\u00e9 (4 <em>retries<\/em> maximum par exemple).<\/p>\n<p>Pour voir une autre impl\u00e9mentation tr\u00e8s int\u00e9ressante, je vous invite \u00e0 lire <a href=\"https:\/\/rossta.net\/blog\/a-ruby-antihero-thread-pool.html\">cet article<\/a> dont je me suis pas mal inspir\u00e9 (en anglais).<\/p>\n","protected":false},"excerpt":{"rendered":"<p>\u00c9criture d&rsquo;une thread pool en Ruby<\/p>\n","protected":false},"author":10,"featured_media":12474,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34],"tags":[],"class_list":["post-7899","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>\u00c9crire une thread pool en Ruby - Ouidou<\/title>\n<meta name=\"description\" content=\"D\u00e9couvrez comment \u00e9crire une thread pool en Ruby avec ce guide d\u00e9taill\u00e9, pour optimiser la gestion de vos threads efficacement.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"\u00c9crire une thread pool en Ruby - Ouidou\" \/>\n<meta property=\"og:description\" content=\"D\u00e9couvrez comment \u00e9crire une thread pool en Ruby avec ce guide d\u00e9taill\u00e9, pour optimiser la gestion de vos threads efficacement.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2019-01-09T23:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-08-30T09:39:06+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/01\/a-8.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"5 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"\u00c9crire une thread pool en Ruby\",\"datePublished\":\"2019-01-09T23:00:00+00:00\",\"dateModified\":\"2024-08-30T09:39:06+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby\"},\"wordCount\":1117,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/01\\\/a-8.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby\",\"name\":\"\u00c9crire une thread pool en Ruby - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/01\\\/a-8.png\",\"datePublished\":\"2019-01-09T23:00:00+00:00\",\"dateModified\":\"2024-08-30T09:39:06+00:00\",\"description\":\"D\u00e9couvrez comment \u00e9crire une thread pool en Ruby avec ce guide d\u00e9taill\u00e9, pour optimiser la gestion de vos threads efficacement.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/01\\\/a-8.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/01\\\/a-8.png\",\"width\":1105,\"height\":564},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-une-thread-pool-en-ruby#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"\u00c9crire une thread pool en Ruby\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"\u00c9crire une thread pool en Ruby - Ouidou","description":"D\u00e9couvrez comment \u00e9crire une thread pool en Ruby avec ce guide d\u00e9taill\u00e9, pour optimiser la gestion de vos threads efficacement.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby","og_locale":"fr_FR","og_type":"article","og_title":"\u00c9crire une thread pool en Ruby - Ouidou","og_description":"D\u00e9couvrez comment \u00e9crire une thread pool en Ruby avec ce guide d\u00e9taill\u00e9, pour optimiser la gestion de vos threads efficacement.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby","og_site_name":"Ouidou","article_published_time":"2019-01-09T23:00:00+00:00","article_modified_time":"2024-08-30T09:39:06+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/01\/a-8.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"\u00c9crire une thread pool en Ruby","datePublished":"2019-01-09T23:00:00+00:00","dateModified":"2024-08-30T09:39:06+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby"},"wordCount":1117,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/01\/a-8.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby","name":"\u00c9crire une thread pool en Ruby - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/01\/a-8.png","datePublished":"2019-01-09T23:00:00+00:00","dateModified":"2024-08-30T09:39:06+00:00","description":"D\u00e9couvrez comment \u00e9crire une thread pool en Ruby avec ce guide d\u00e9taill\u00e9, pour optimiser la gestion de vos threads efficacement.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/01\/a-8.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/01\/a-8.png","width":1105,"height":564},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-une-thread-pool-en-ruby#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"\u00c9crire une thread pool en Ruby"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7899","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7899"}],"version-history":[{"count":4,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7899\/revisions"}],"predecessor-version":[{"id":16019,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7899\/revisions\/16019"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/12474"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7899"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7899"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7899"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}