Folyamat (számítástechnika)
A számítástechnikában a folyamat egy számítógépes program példánya, amelyet egy vagy több szál hajt végre. Ez tartalmazza a programkódot és a tevékenységét. Operációs rendszertől (OS) függően egy folyamat több végrehajtási szálból állhat, amely utasításokat egyidejűleg hajtják végre.[1][2]
Míg a számítógépes program passzív utasítások gyűjteménye, addig a folyamat ezen utasítások tényleges végrehajtása. Több folyamat társítható ugyanahhoz a programhoz; például ugyanazon program több példányának megnyitása gyakran egynél több folyamat végrehajtását eredményezi.
A többfeladatosság olyan módszer, amely lehetővé teszi több folyamat számára a processzorok (CPU) és más rendszererőforrások megosztását. Minden processzor (mag) egyszerre egyetlen feladatot hajt végre. A többfeladatosság azonban lehetővé teszi, hogy minden processzor válthasson a feladatok között anélkül, hogy meg kellene várnia az egyes feladatok befejezését (preempció). Az operációs rendszer megvalósításától függően kapcsolásokat lehet elvégezni, amikor a feladatok elindítják és megvárják a bemeneti/kimeneti műveletek befejezését, amikor egy feladat jelzi, hardvermegszakítások esetén, és amikor az operációs rendszer ütemezője úgy dönt, hogy egy folyamatnak lejárt a tisztességes részesedése a processzoridőből (pl. a Completely Fair Scheduler Linux-kernel esetén).
A többfeladatosság általános formáját a processzor az időosztás által biztosítja, mely egy módszer a felhasználói folyamatok és szálak, sőt a független kernelfeladatok végrehajtásának összeillesztésére – bár ez utóbbi funkció csak olyan preemptív kerneleken valósítható meg, mint például a Linux. A preempciónak fontos mellékhatása van az interaktív folyamatok számára, amelyek nagyobb prioritást élveznek a processzorigényes folyamatokhoz képest, ezért a felhasználók azonnal kiosztják a számítási erőforrásokat egy gombnyomás vagy az egér mozgatása közben. Ezenkívül az olyan alkalmazások, mint a videó- és a zenelejátszók, valamilyen valós idejű prioritást kapnak, megelőzve minden más alacsonyabb prioritású folyamatot. Az időosztásos rendszerekben a kontextusváltásokat gyorsan hajtják végre, ami miatt úgy tűnik, hogy több folyamat egyidejűleg hajtódik végre ugyanazon a processzoron. Több folyamat egyidejű végrehajtását egyidejűségnek hívják.
A biztonság és a megbízhatóság érdekében a legtöbb modern operációs rendszer megakadályozza a független folyamatok közötti közvetlen kommunikációt, szigorúan közvetített és ellenőrzött folyamatok közötti kommunikációs funkciókat biztosítva.
Bemutatás szerkesztés
Általában véve egy számítógépes rendszer folyamata a következő erőforrásokból áll:
- Egy programhoz társított végrehajtható gépi kód képe.
- Memória (általában a virtuális memória valamilyen régiója); amely magában foglalja a végrehajtható kódot, a folyamatspecifikus adatokat (bemeneti és kimeneti), egy hívási vermet (az aktív alprogramok és/vagy egyéb események nyomon követéséhez) és egy halom a futási idő során generált közbenső számítási adatot.
- A folyamathoz hozzárendelt erőforrások operációsrendszer-leírói, például fájlleírók (Unix-terminológia) vagy leírók (Windows), valamint adatforrások és -összefoglalók.
- Biztonsági attribútumok, például a folyamat tulajdonosa és a folyamat engedélyei (megengedett műveletei).
- A processzor állapota (kontextus), például a regiszterek tartalma és fizikaimemória-címzése. Az állapotot általában számítógépes regiszterekben tárolják, amikor a folyamat végrehajtódik, egyébként pedig a memóriában.[1]
Az operációs rendszer az aktív folyamatokkal kapcsolatos információk nagy részét folyamatvezérlő blokkoknak nevezett adatszerkezetekben tárolja. Bármilyen részhalmaza az erőforrásoknak, jellemzően legalább a processzor állapota, összefüggésben lehet minden folyamat szálaival olyan operációs rendszerek esetében, amelyek támogatják a szálakat vagy a gyermekfolyamatokat (child processes).
Az operációs rendszer elválasztja a folyamatokat és elosztja a szükséges erőforrásokat, hogy azok kevésbé zavarják egymást, és ezzel rendszerhibákat okozzanak (pl. holtpont vagy vergődés). Az operációs rendszer mechanizmusokat is biztosíthat a folyamatok közötti kommunikációhoz, lehetővé téve a folyamatok biztonságos és kiszámítható módon történő kölcsönhatását.
Többfeladatosság és folyamatkezelés szerkesztés
A többfeladatos operációs rendszer tud váltani a folyamatok között, így úgy tűnhet, mintha a folyamatokat egyidejűleg (azaz párhuzamosan) hajtaná végre, de valójában csak egy folyamatot tud végrehajtani egy időben egyetlen processzoron (kivéve, ha a processzor több maggal rendelkezik, akkor többszálú végrehajtást vagy más hasonló technológiákat lehet használni).[* 1]
Általában egy folyamatot egy főprogramhoz társítunk, a gyermekfolyamatokat pedig minden mellékághoz, párhuzamos folyamathoz, amelyek az aszinkron alprogramokhoz hasonlóan viselkednek. Azt mondjuk, hogy egy folyamatnak megvannak a saját erőforrásai, amelyek közül a program képe (a memóriában) egy ilyen erőforrás. A többprocesszoros rendszerekben azonban sok folyamat lefuthat vagy megoszthatja ugyanazt az újrahívható (reentrant) programot ugyanazon a helyen a memóriában, de azt mondjuk, hogy mindegyik folyamatnak megvan a saját képe.
A folyamatokat gyakran feladatoknak nevezik a beágyazott operációs rendszerekben. A folyamat (vagy feladat) jelentése „valami, ami időt vesz igénybe”, szemben a memóriával, amely „valami, ami helyet foglal el”.[* 2]
A fenti leírás vonatkozik mind az operációs rendszer által kezelt folyamatokra, mind azokra a folyamatokra, amelyeket folyamatkalkulus határoz meg.
Ha egy folyamat valami olyat kér, amire várnia kell, akkor blokkolva lesz. Ha a folyamat blokkolt állapotban van, akkor lemezre cserélhető, de ez átlátható egy virtuálismemória-rendszerben, ahol a folyamat memóriájának régiói valóban a lemezen vannak és nem a főmemóriában. Vegye figyelembe, hogy akár az aktív folyamatok/feladatok (végrehajtó programok) is cserélhetők lemezre, ha az utóbbi időben nem használták őket. Nem kell a végrehajtó program összes részének a fizikai memóriában lennie, hogy a társított folyamat aktív legyen.
Folyamatállapotok szerkesztés
Egy operációs rendszer rendszermagjának, amely lehetővé teszi a többfeladatosságot, szüksége van arra, hogy a folyamatoknak legyenek bizonyos állapotai. Ezeknek az állapotoknak a nevei nincsenek szabványosítva, de hasonló funkcióval rendelkeznek.[1]
- Először a folyamatot létrehozzuk egy másodlagos tárolóeszközről (merevlemez-meghajtó, CD-ROM stb.) a főmemóriába töltéssel. Ezután a folyamatütemező hozzárendeli a várakozó állapotot.
- Amíg a folyamat várakozó állapotban van, addig az ütemező elvégzi az úgynevezett kontextusváltást. A kontextusváltás betölti a folyamatot a processzorba és az állapotot futóra változtatja, miközben az előzőleg futó folyamat várakozó állapotban van tárolva.
- Ha a futó állapotban levő folyamatnak meg kell várnia egy erőforrást (például várnia kell a felhasználói bemenetre vagy egy fájl megnyitására), akkor blokkolt állapotba kerül. A folyamat állapota visszaáll várakozóra, amikor a folyamatnak már nem kell várnia (blokkolt állapotban).
- Amint a folyamat befejezi a végrehajtást vagy az operációs rendszer leállítja, nincsen már rá szükség. A folyamat azonnal eltávolításra vagy befejezett állapotba kerül. Eltávolításkor csak arra vár, hogy eltávolítsák a főmemóriából.[1][3]
Folyamatok közötti kommunikáció szerkesztés
Amikor a folyamatoknak kommunikálniuk kell egymással, meg kell osztaniuk a címterük egy részét vagy más folyamatok közötti kommunikációt (IPC) kell használniuk. Például egy héjfutószalagon (shell pipeline) az első folyamat kimenetének el kell jutnia a másodikhoz és így tovább; egy másik példa egy olyan feladat, amelyet fel lehet bontani együttműködő, de részben független folyamatokra, amelyek egyszerre futhatnak (vagyis egyidejűséget vagy valódi párhuzamosságot használnak – ez utóbbi modell az egyidejű végrehajtás konkrét esete, és megvalósítható, ha elegendő processzormag áll rendelkezésre az összes folyamat számára, amelyek készen állnak a futtatásra).
Lehetséges, hogy két vagy több folyamat különböző gépeken fut, amelyek eltérő operációs rendszert (OS) futtatnak, ezért szükség van bizonyos (az elosztott számítástechnikában kommunikációs protokolloknak nevezett) kommunikációs és szinkronizálási mechanizmusokra (pl. a Message Passing Interface, amelyet gyakran egyszerűen MPI-nek hívnak).
Előzmények szerkesztés
Az 1960-as évek elején a számítógépes vezérlőszoftver a monitorvezérlő szoftverekről, például az IBSYS, a végrehajtóvezérlő-szoftverekké fejlődött. Az idő múlásával a számítógépek gyorsabban fejlődtek, miközben a számítógépes idő még mindig nem volt olcsó és nem volt teljes mértékben kihasználva; egy ilyen környezet lehetővé és szükségessé tette a multiprogramozást. A multiprogramozás azt jelenti, hogy több program fut egyidejűleg. Eleinte egynél több program futott egy processzoron az egyprocesszoros számítógép-architektúra eredményeként, szűkös és korlátozott hardver-erőforrásokon osztoztak; következésképpen az egyidejűség soros jellegű volt. A későbbi többprocesszoros rendszereken egyszerre több program futhat párhuzamosan.
A programok utasításokat tartalmaznak a processzorok számára. Egy processzor egyszerre csak egy utasítást futtathat: lehetetlen több program futtatása egyszerre. Előfordulhat, hogy egy programnak valamilyen erőforrásra, például bemeneti eszközre van szüksége, amely nagy késleltetéssel rendelkezik vagy egy program lassú műveletet indíthat, például kimenetet küldhet egy nyomtatóra. Ez azt eredményezné, hogy a processzor kihasználatlan marad (üresjárat). Annak érdekében, hogy a processzor mindig el legyen foglalva, egy ilyen program végrehajtását leállítják, és az operációs rendszer átváltja a processzort egy másik program futtatására. A felhasználó számára úgy tűnik, hogy a programok egyszerre futnak (innen a „párhuzamos” kifejezés).
Röviddel ezután a „program” fogalmát kibővítették a „végrehajtó program és annak összefüggései” fogalmára. Megszületett egy folyamat koncepciója, amely az újrahívható kód feltalálásával szükségessé vált. A szálak valamivel később jöttek. Azonban az olyan fogalmak megjelenésével, mint az időosztás, a számítógép-hálózatok és a többprocesszoros közösmemória-számítógépek, a régi „multiprogramozás” helyet adott a valódi többfeladatosság (multitasking), a többfolyamatos (multiprocessing) és később a többszálú végrehajtás (multithreading) számára.
Megjegyzések szerkesztés
- ↑ Néhány modern processzor két vagy több független processzort egyesít többmagos konfigurációban, és több folyamatot is végrehajthat egyszerre. Egy másik módszer, amelyet szimultán többszálú végrehajtásnak hívnak (az Intel Hyper-Threading technológiájában használják), szimulálhatja több folyamat vagy szál egyidejű végrehajtását.
- ↑ A feladatok (tasks) és a folyamatok (processes) lényegében ugyanazon entitásra vonatkoznak. Bár némileg eltérő terminológiai történeteik vannak, szinonimákként használják őket. Manapság a folyamat kifejezést előnyben részesítik a feladathoz képest, kivéve, ha a többfeladatosságra (multitasking) utalnak, mivel a többfolyamatos (multiprocessing) alternatív kifejezést túlságosan könnyű összekeverni a többprocesszoros (multiprocessor) kifejezéssel (amely két vagy több processzorral rendelkező számítógépet jelent).
Hivatkozások szerkesztés
- ↑ a b c d Chapter 4. Processes, Operating system concepts with Java, Sixth, John Wiley & Sons (2004. április 2.). ISBN 0-471-48905-0
- ↑ Vahalia, Uresh. Chapter 2. The Process and the Kernel, UNIX Internals: The New Frontiers. Prentice-Hall Inc. (1996. április 2.). ISBN 0-13-101908-2
- ↑ Stallings, William. Operating Systems: internals and design principles, 5th, Prentice Hall (2005. április 2.). ISBN 0-13-127837-1 (particularly chapter 3, section 3.2, "process states", including figure 3.9 "process state transition with suspend states")
Fordítás szerkesztés
- Ez a szócikk részben vagy egészben a Process (computing) című angol Wikipédia-szócikk ezen változatának 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.
További információk szerkesztés
- Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau (2014). Operating Systems: Three Easy Pieces. Arpaci-Dusseau Books. Relevant chapters: Abstraction: The Process The Process API
- Gary D. Knott (1974) A proposal for certain process management and intercommunication primitives ACM SIGOPS Operating Systems Review. Volume 8, Issue 4 (October 1974). pp. 7 – 44
