Szálkészlet programtervezési minta

A számítógép programozásban a szálkészlet (angolul Thread Pool) egy programtervezési minta, amely során a szálak azért jönnek létre, hogy párhuzamosan végrehajtsák a meghatározott számú sorba rendezett feladatokat. A készlet létrehozásának oka az, hogy megspóroljuk a szálak gyakori létrehozásának és bezárásának költségeit, amely főleg akkor jelenthet gondot, ha az egyes feladatok rövid ideig futnak. Az objektumkészlet speciális esete.^[1] Számukat a rendszer erőforrásai határozzák meg.^[2]

Általában több feladat van, mint ahány szál. Folyamatosan érkezhetnek újabb feladatok, amelyek egy sorba kerülnek. A feladatok sora szinkronizált, és lehet elsőbbségi sor is. Amint egy szál elvégzi a feladatát, az kérvényez egy másik feladatot a sorból, amíg minden feladat el nem fogy. A szál ezt követően megszakad, vagy alvó állapotba lép, amíg nem keletkezik új elvégezhető feladat.

Darabszám és sebesség

A szálak darabszáma általában paraméterként változtatható a legjobb teljesítmény biztosítása érdekében. A darabszám dinamikusan is változhat, a várakozó feladatok száma szerint.^[3] Mivel csak kezdetben és szükség esetén kell új szálat létrehozni, bezárni pedig csak a végén kell, ezzel a többszálú program felgyorsul és stabilabbá válik.

Például egy web szerver még több szálat hozhat létre ha a weboldal azt kéri, vagy akár el is távolíthat közülük. Minél nagyobb a szálkészletünk (Thread Pool-unk) annál erőforrás igényesebb lesz. A túl sok fölösleges szál memóriapazarlás, és a szálak váltogatása további költséget jelent. A szálakhoz erőforrások is rendelhetők, például észszerű, ha a szerver a socket kapcsolatokat hozzárendeli egy-egy szálhoz, és azt a szál több feladathoz is használja.

A használt algoritmus meghatározza, hogy mikor kell létrehozni, illetve megsemmisíteni a szálakat, és ez hatással van az általános teljesítményre.

Túl sok szál létrehozása idő és erőforrás pocséklást jelent.
Túl sok szál megsemmisítése (bezárása, befejezése) még több időpocséklást jelent a későbbi újra létrehozásuk miatt.
A szálakat túl lassan létrehozva gyenge teljesítményű klienset fog eredményezni a hosszú várakozási idők miatt.
A szálakat túl lassan megsemmisítve, a többi szálat „éheztetjük”.

Az algoritmus a fennálló helyzet valamelyike alapján kiválasztja az optimális mintát. Ha a feladatok száma túl nagy, akkor új szállak létrehozása feladatonként nem túl optimális. Egyéb előnye a használatának azon felül, hogy kreálhatunk új szálakat feladatonként az, hogy a szál létrehozás és megsemmisítés kiegyenlítődik, ami jobb teljesítményt és jobb rendszer stabilitást eredményez. Létrehozni, vagy megszüntetni új szálakat és az ahhoz kapcsolódó erőforrásokat költséges folyamat az idő tekintetében. Túl sok szálal csak pazaroljuk a memóriát, és a szálak közötti váltások szintén károsak a teljesítményre. Például, egy csatlakozón keresztüli kapcsolat egy másik géphez - ami akár több ezer, vagy több millió „drop” és „re-establish” ciklusból is állhat - elkerülhető.

Szálbiztosság

Amikor ezt a mintát megvalósítjuk, a programozónak biztosítania kell a szálbiztosságot a sorban. Java-ban lehetőség van a metódusok szinkronizálására a synchronized kulcsszóval. Ez hozzáköti a módosított blokkot egy atomi szerkezethez, ennélfogva kényszerítve minden erőforrást használó szálat arra, hogy várjanak addig, amíg nincsen már szál, ami erőforrást használni. Ennek hátránya, hogy ez a metódus drága. Létre tudsz hozni egy olyan objektumot, amely egy listát tart minden munkafeladatról a sorban, ami lehet egyke is.

A szálak általában egyazon számítógépen hajtódnak végre. Azonban a szálkészlet fogalma kapcsolódik a szerver farm fogalmához, ahol van egy kiszolgáló (master), ami lehet egy szálkészlet is. És ez a kiszolgáló osztja szét a különböző beérkező feladatokat a különböző számítógépeken (munkás, worker) futó szálak között, ezáltal is növelve az általános teljesítményt.

Források

Garg, Rajat P. & Sharapov, Ilya Techniques for Optimizing Applications - High Performance Computing Prentice-Hall 2002, p. 394

További információk

Analysis of optimal thread pool size (Yibei Ling, Tracy Mullen and Xiaola Lin)
Query by Slice, Parallel Execute, and Join: A Thread Pool Pattern in Java (Binildas C. A.)
Thread pools and work queues (Brian Goetz)
A Method of Worker Thread Pooling (Pradeep Kumar Sahu)
Work Queue (Uri Twig)
Windows Thread Pooling and Execution Chaining
Smart Thread Pool (Ami Bar)
Programming the Thread Pool in the .NET Framework (David Carmona)
The Thread Pool and Asynchronous Methods (Jon Skeet)
Creating a Notifying Blocking Thread Pool in Java (Amir Kirsh)
Practical Threaded Programming with Python: Thread Pools and Queues (Noah Gift)
Optimizing Thread-Pool Strategies for Real-Time CORBA (Irfan Pyarali, Marina Spivak, Douglas C. Schmidt és Ron Cytron)
Deferred cancellation. A behavioral pattern (Philipp Bachmann)
threadpool11
C++ Thread Pool Library

Jegyzetek

↑ Holub, Allen. Taming Java Threads. Apress, 209. o. (2000)
↑ TCP/IP Sockets in C#: Practical Guide for Programmers. Academic Press, 112. o. (2004)
↑ Yibei Ling (2000. április 1.). „Analysis of optimal thread pool size”. ACM SIGOPS Operating Systems Review 34 (2), 42–55. o.

Fordítás

Ez a szócikk részben vagy egészben a Thread pool című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

[1] Holub, Allen. Taming Java Threads. Apress, 209. o. (2000)

[2] TCP/IP Sockets in C#: Practical Guide for Programmers. Academic Press, 112. o. (2004)

[ACM,_Thread_pool_size-3] Yibei Ling (2000. április 1.). „Analysis of optimal thread pool size”. ACM SIGOPS Operating Systems Review 34 (2), 42–55. o.

[1]

[2]

[3]