A menet vagy huzal (futás) , vagy feladat (kifejezés és meghatározás által szabványosított ISO / IEC 2382-7: 2000 Egyéb nevek ismertek: könnyű folyamat , használati szál , áramvonalas folyamat , exétron vagy végrehajtási egység vagy egység folyamat ) az hasonló egy folyamathoz, mivel mindkettő egy gépi nyelv utasításainak halmazát jeleníti meg egy processzortól . A felhasználó szempontjából úgy tűnik, hogy ezek a kivégzések párhuzamosan zajlanak . Azonban ahol minden folyamatnak megvan a maga virtuális memóriája , ugyanannak a folyamatnak a szálai megosztják virtuális memóriáját. Az összes szálnak azonban megvan a maga végrehajtási vereme .
A szálakat általában egy program GUI-jával ( grafikus felhasználói felület ) használják, aszinkron elvárásoknak megfelelően a telekommunikációban, vagy a HPC programok számára (például videó kódolása, matematikai szimulációk stb.).
Valójában egy grafikus felület esetében a felhasználó és a folyamat interakcióit a bemeneti eszközök közvetítésével egy szál kezeli, az aszinkron várakozásokhoz hasonló technikával, míg a nehéz számítások (a számítási idő) egy vagy több másik szál kezeli . Ez a szoftvertervezési technika azért előnyös ebben az esetben, mert a felhasználó továbbra is kölcsönhatásba léphet a programmal, még akkor is, ha az feladatot végez . Gyakorlati alkalmazás található a szövegszerkesztőkben, ahol a helyesírás-ellenőrzést végzik, miközben a felhasználó tovább folytathatja a szöveg bevitelét. A szálak használata tehát lehetővé teszi az alkalmazás használatának folyékonyabbá tételét, mivel az intenzív feldolgozási fázisokban már nincs blokkolás.
Intenzív számítástechnikai program esetén több szál használata lehetővé teszi a feldolgozás párhuzamosítását , amely többprocesszoros gépeken sokkal gyorsabb végrehajtást tesz lehetővé.
Két folyamat teljesen független és elszigetelt egymástól. Csak egy rendszer által biztosított API-n , például az IPC - n keresztül léphetnek kapcsolatba , miközben a szálak információkat osztanak meg a folyamat állapotáról, a memóriaterületekről és más erőforrásokról. Tény, hogy eltekintve a hívási verem , mechanizmusok, mint a téma helyi tárolás, és néhány ritka kivételtől eltekintve az egyes végrehajtás szálak mindent megosztunk. Mivel a virtuális memóriában nincs változás , a két szál közötti kontextus kapcsoló ( kontextus kapcsoló ) kevésbé időigényes, mint a két folyamat közötti kontextus kapcsoló. Ez a több szál használatával történő programozás előnyének tekinthető .
Bizonyos esetekben a szálakat használó programok gyorsabbak, mint a hagyományos architektúrájú programok , különösen a több processzorral rendelkező gépeken . A kontextusváltás költségének kérdésén kívül a több folyamat használata miatt felmerülő fő költségek a különálló folyamatok közötti kommunikációból származnak. Az erőforrások szálak közötti megosztása valóban hatékonyabb kommunikációt tesz lehetővé a folyamat különböző szálai között, mint két külön folyamat között. Ahol két különálló folyamatnak a rendszer által biztosított mechanizmust kell használnia a kommunikációhoz, a szálak megosztják a folyamat állapotának egy részét, beleértve annak memóriáját is. Csak olvasható adatok esetén nincs szükség semmilyen szinkronizálási mechanizmusra ahhoz , hogy a szálak ugyanazokat az adatokat használják.
A programozás segítségével szálak azonban szigorúbb szekvenciális programozás , és a hozzáférést néhány megosztott erőforrásokat kell korlátozni magát a programot, hogy megakadályozzák az állam egy folyamat lesz átmenetileg nincs, míg a másik szál lesz szüksége, hogy megtekinthesse ezt a a folyamat állapotának része. Ezért kötelező a szinkronizálási mechanizmusok felállítása (például szemaforák felhasználásával ), szem előtt tartva, hogy a szinkronizálás holtponthoz vezethet, ha helytelenül használják.
A szálakat használó programok komplexitása is lényegesen nagyobb, mint azoknál a programoknál, amelyek egymást követõen több egyszerûbb folyamatra halasztják az elvégzendõ munkát (a bonyolultság több párhuzamosan mûködõ folyamat esetén is hasonló). Ez a megnövekedett bonyolultság, ha a program tervezési vagy végrehajtási szakaszában rosszul kezelik , több problémához vezethet, például:
Az operációs rendszerek általában végre a szálakat , gyakran nevezik szál rendszer vagy szálak natív (ellentétben a szálak kapcsolódik egy programozási nyelv adni). Ezeket az operációs rendszerhez tartozó API- n keresztül használják , például a Windows API-n vagy a POSIX szálakon . Általában ez az API nem objektumorientált, és viszonylag bonyolult lehet a megfelelő megvalósítása, mivel csak primitív függvényekből áll , amelyek gyakran némi ismeretet igényelnek az ütemező működéséről .
A natív szálak előnye, hogy maximális teljesítményt nyújtanak, mivel az API-k segítenek minimalizálni a kernelben töltött időt és kiküszöbölni a felesleges szoftverrétegeket. Fő hátrányuk az API primitív jellege miatt a megvalósítás nagyobb komplexitása.
Egyes programozási nyelvek, például a Smalltalk és a Java egyes megvalósításai , integrálják a felhasználói térben megvalósított szálak támogatását ( zöld szálak (be) ), függetlenül a gazdagép operációs rendszerének képességeitől.
A legtöbb nyelv ( Java a legtöbb operációs rendszeren, C # .NET , C ++ , Ruby ...) nyelvi kiterjesztéseket vagy könyvtárakat használ az operációs rendszer többszálú szolgáltatásainak közvetlen , de hordozható módon történő felhasználására. Végül, a Haskellhez hasonló nyelvek hibrid rendszert használnak a két megközelítés között félúton. Megjegyzendő, hogy a teljesítmény miatt igény szerint, a legtöbb nyelv lehetővé teszi a választott natív szálak vagy zöld szálak (különösen alkalmazása révén rostok ). Más nyelvek, például az Ada (nyelv) , szintén az operációs rendszertől független multitaskingot valósítják meg, anélkül, hogy a szálak fogalmát ténylegesen alkalmaznák .
A C ++, mivel az új C ++ 11 nevű C ++ szabvány rendelkezik egy szálkezelő könyvtárral (a Boost-tól ): az osztálymodell az std::thread. Ez könnyen használható, és lehetővé teszi a szálak létrehozását és végrehajtását . Korábban minden keretrendszernek saját szálkezelési átfedést kellett megvalósítania , általában közvetlenül a rendszer natív szálaihoz vezetve .
A párhuzamos programozás során az alapelv a szálak által használt szoftveralanyok újbóli belépésének biztosítása , akár tervezéssel ( tiszta funkciók ), akár szinkronizálással (különösen a függvény hívását körülvevő mutex használatával ).
Eljárási programozásAz eljárási programozás során az operációs rendszer natív szálait használják leggyakrabban közvetlenül . Használatuk ekkor közvetlenül függ a rendszer API-jától, annak előnyeivel és hátrányaival. Különösen a szálak által használt funkcióknak kell újból belépniük vagy a mutex által védettnek lenniük.
Objektumorientált programozásAz objektum-orientált programozásban a szálak használata általában egy általános szülő osztályból (vagy osztály modellből) való öröklés útján történik, tiszta virtuális módszerrel, amely a párhuzamosan végrehajtandó kódot tartalmazza. Meg kell írnia a származtatott osztályt, és végre kell hajtania a párhuzamosítani kívánt példányt , példányosítani kell, és meg kell hívnia egy adott metódust (gyakran Run vagy egyenértékűnek hívják ) a szál elindításához . Vannak módszerek a feladat leállítására vagy megvárására is, ami nagyban leegyszerűsíti az egyszerű szálak létrehozását . Azonban sokkal bonyolultabb művelet ( barrier a nagyszámú szálak , pontos prioritási beállítások , stb) és esetleg kevésbé könnyen, mint használ natív szálak .
Beszélünk egy beugró osztály , amikor külön példányait egy ilyen osztály mindegyike lehet használni szálak mellékhatások nélkül hatás , ami általában azt jelenti, távollét globális vagy statikus elem végrehajtása során az osztály. Beszélünk egy szálbiztos osztályról is, amikor több szál használhatja az osztály egyetlen példányát anélkül, hogy ezzel párhuzamossági problémák lennének. A szálbiztos osztály szükségszerűen visszatér, de fordítva hamis.
Funkcionális programozásJellegét tekintve, mivel a funkcionális programozásban minden újból belép - és gyakran szálbiztos - néhány ritka kivételtől eltekintve, ez a paradigma nagymértékben leegyszerűsíti a szálak megvalósítását . Általánosságban elmondható, hogy a kód párhuzamosítása csak a szerződéstől és a hívássorozattól függ : természetesen megköveteli az előtti számítást , ami megakadályozza a két funkció párhuzamosítását. De ezek a korlátozások nem csak a funkcionális programozásra jellemzőek, hanem a megvalósított algoritmusban rejlenek.
Számos minta profitálhat a szálakból , például a Decorator , a Factory Method , a Command vagy a Proxy . Általánosságban elmondható, hogy a minta bármilyen szoftveralanynak történő továbbítása a szálak használatának tárgya lehet .
További klasszikus példák:
Egyes Intel processzorok Hyper-Threading technológiáját nem szabad összetéveszteni a szálakkal . Ez a technológia lehetővé teszi külön folyamatok és szálak egyidejű végrehajtását . Bármely, több processzort ( SMP ) vagy Hyper-Threadinget integráló processzort tartalmazó gép lehetővé teszi a programok gyorsabb végrehajtását szálak és több folyamat segítségével.