Érdekes módon a PowerShell alatt meghúzódó .NET keretrendszer rendelkezik olyan osztályokkal, melyek lehetővé teszik a többszálú végrehajtást, bár ez még távolról sincs még a PowerShell szintjére felemelve, eléggé rejtett módon érhető ez a hasznos lehetőség. Mindez a http://powershell.com weboldal, illetve Dr. Tobias Weltner (PowerShell MVP) jóvoltából most már számomra és mindenki más számára is hozzáférhető tudás.
Tudjuk már, hogy a PowerShell segítségével akár nagytömegű objektumon tudunk műveletet végezni, akár a hagyományos foreach ciklus, vagy a csővezeték-szerű működést megvalósító ForEach-Object cmdlet segítségével is. Ezekkel az a baj, hogy ha az 1000 objektum feldolgozása közben egyik-másik feldolgozása több időt vesz igénybe, akkor az az egész feldolgozás befejezését késlelteti. Ezzel szemben, ha párhuzamosan tudjuk a műveleteket elvégezni, akkor a befejezés ideje ideális esetben annyiad része lesz a korábbiaknak, ahány szálon tudjuk futtatni a feldolgozást. Persze a helyzet általában nem ideális, hiszen a processzorunk teljesítménye általában nem növelhető a szálak számával egyenes arányban és a többszálúság kezelése némi „overhead”-et is jelent, de ha például távoli gépekkel kommunikálunk a feldolgozás során, amelyekre várni kell, akkor már jelentősen közeledhetünk az ideális gyorsulás felé.
Az egyik lehetőség a többszálúságra a háttérben futtatás, amit az 1.11 Futtatás háttérben és távol fejezetben már láthattunk is. Ilyenkor ahogy egy ’job’-ot elindítunk, nem kell megvárni a teljes végrehajtást, hanem már rögtön indíthatjuk a következőt. Persze egy-egy háttérfolyamat létrehozása is jelentős időbe telik (néhány másodperc), plusz a háttérfolyamatokhoz az adatok átadása és visszavétele is igényel feldolgozást (szerializáció – deszerializáció), így csak akkor éri meg ezzel élni, ha maga a feladat ennél jelentősebb ideig tart.
Az is gondot okoz a háttérfolyamatoknál, hogy nem tudjuk őket indításuk után vezérelni. Azaz dilemmába esünk, hogy egy 1000 elemes feldolgozásnál hány háttérfolyamatot is indítsunk? Valószínű 1000-et nem érdemes, 1-nél meg nincs is szükség háttérfolyamatra. Azaz az ideális valahol a kettő között van. Mondjuk, legyen 10 párhuzamos szálunk, azaz 10 háttérfolyamatunk, de nekünk kell már indításkor szétosztani a munkadarabokat a 10 feldolgozóegységünk között. Rossz esetben az egyik egység kapja a legmunkaigényesebb 100 munkadarabot, így a többi már rég kész lesz és unatkozik, amikor ezek feldolgozása még jócskán folyik.
Az ideális a ’throttling’ mechanizmus lenne, azaz egy közös sorban várnak a munkadarabok, és az aktuális mindig az éppen felszabaduló feldolgozó egységhez kerül. Szerencsére ez is megoldható a többszálúságot biztosító osztályok segítségével.