Szálkészlet programtervezési minta

A zöld dobozokkal jelzett példa szálkészlet kék várakozó és sárga teljesített feladatokkal

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égSzerkesztés

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 a legoptimálisabb 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ágSzerkesztés

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ásokSzerkesztés

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

További információkSzerkesztés

JegyzetekSzerkesztés

  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) 
  3. Yibei Ling (2000. április 1.). „Analysis of optimal thread pool size”. ACM SIGOPS Operating Systems Review 34 (2), 42–55. o.  

FordításSzerkeszté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.