A 2. fejezetben már láttuk a program és a folyamat közti különbséget, ami alapvetően úgy összegezhető, hogy a folyamat (process) nem más, mint egy program éppen futó példánya, a programkód és a futáskor hozzárendelt adatterület, a maga processz-példányonként egyedi tartalmával. (Szemléletes hasonlattal élve, amikor többen használják mondjuk a cat parancsot, az egyes elindított folyamatok programkódja közös (hiszen ugyanaz a program fut), de az adatszegmens más és más, attól függően, hogy melyik folyamat melyik fájlt listázza, hol tart a listázásban stb.) Ebből az is leszűrhető, hogy a UNIX, mint többfelhasználós és többfeladatos rendszer alatt, a folyamat az egyik legalapvetőbb egység, amivel az operációs rendszer dolgozik. Az alábbiakban a folyamatkezeléssel foglalkozunk egy kicsit, különös tekintettel a háttérben futtatásra és a folyamatok időzített végrehajtására.

Láttuk az előzőekben, hogy egy parancssorban több programot is elindíthatunk, ha pontosvesszővel elválasztva gépeljük be őket. Ez esetben a programok (pontosabban: a folyamatok) egymástól teljesen függetlenül de, egymás után, szekvenciálisan futnak le, amíg az első parancs által indított le nem fut, a következő nem indul el. A UNIX azonban egyidejűleg több program futtatására is képes. Tegyük fel, hogy van egy időigényes programunk, amelynek futtatását nem feltétlenül tudtuk az ebédszünetre időzíteni, s valami más hasznosat is szeretnénk csinálni, amíg az fut. Ez esetben a háttérben futó folyamatként elindíthatjuk a programot, elindítása után a parancsértelmező rögtön visszaadja a promptot, s nem kell a program befejeződésére várni, futtathatunk valami mást.

A fenti példában az ilyenugyselesz stringet keressük a gyökérkatalógus állományaiban, s az eredményt az aktuális katalógusban az eredmeny nevű állományba íratjuk. A parancssor végén az '&' jel jelzi, hogy a programot a shell háttérfolyamatként (background process) indíthatja, s nem kell a befejeződését megvárnia. A felhasználó számára ez abban jelentkezik, hogy rögtön visszakapja a promptot, s a rendszer kiír egy számot. Ez a szám az adott processz folyamatazonosítója, az úgynevezett process-id (PID). Ezt az azonosítót a későbbiekben az adott processzre való hivatkozásokban használhatjuk. Mivel a folyamat a legalapvetőbb futási entitás a rendszerben, a UNIX minden egyes folyamathoz egy egyedi azonosító értéket rendel, amelyet az adott üzemciklusban (tehát a következő bekapcsolásig) egyidőben senki más nem kap meg.

A process-id leggyakoribb alkalmazása az, amikor egy túl sokáig futó, netán hibás, vagy nem az általunk várt eredményt adó háttérprocesszt le akarunk állítani (nem háttérben futó programot a CTRL-C billentyűvel lehet lelőni). Erre a célra a kill parancs szolgál. Paraméterként a "lelövendő" folyamat PID-jét kell megadni:

Szükségtelen mondani, hogy a felhasználó - hacsak nem rendelkezik superuser jogosítványokkal - csakis a saját maga által elindított folyamatokat lőheti le.

Gyakran előfordul azonban, hogy az ember már nem emlékszik a megállítandó folyamat azonosítójára. A radikális megoldások hívei a kill 0 paranccsal az összes saját futó folyamatukat abortálhatják (magának a bejelentkezéskor elindult login shell-nek a kivételével), van azonban ennél finomabb módszer is, nevezetesen a ps parancs segítségül hívása. A ps alapértelmezés szerint az érdeklődő felhasználó futó folyamatainak legfontosabb adatait listázza ki, köztük a folyamatazonosítót is; ennek birtokában már célzottan hívható meg a kill.

Az eredményül kapott listán az egyes folyamatok azonosítója, a folyamathoz rendelt terminál neve, a folyamat futási ideje és végül a neve látható. A -ef opciók megadásával a rendszerben éppen aktív összes folyamatról kapunk részletes listát, ennek elemzése azonban túlmutat témánkon. (Az viszont sajnálatos módon idevág, hogy a ps parancs listája megint csak rendszerről rendszerre eltérő lehet; a fenti opciók például a System V alapú rendszerekre érvényesek, BSD UNIX verzióknál a ps -ax parancs generál hasonló eredményeket. De ezen túlmenőleg is, az egyes paraméterek kiírási helye és/vagy megadásának módja eltérhet, célszerű mindig utánanézni az online manuálban.)

Különösen számításigényes programoknál jönne jól, ha az ember a háttérben elindíthatná programját, aztán kilépne a rendszerből, és nem kellene várnia a program befejeződését. Normál körülmények között erre nincs mód, mert ha a felhasználó kilép a rendszerből, minden olyan folyamata elhal, amit az ő login termináljáról indítottak el, tehát a háttérfolyamatok is. Ennek elkerülésére szolgál a nohup (no hang-up) parancs.

Alábbi példánkban a nohup paranccsal indított sokaigfutok program a felhasználó kilépése után is tovább fog futni, eredményét pedig, mivel nem lesz terminál, ahova írhatná, a nohup.out nevű állományba rakja (erről a rendszer gondoskodik, nem nekünk kell megadni):

(A nohup parancsot is háttérfolyamatként kell futtatnunk, ha vissza akarjuk kapni a promptot.)

Természetesen a nohup se véd a rendszer lekapcsolása ellen, s egy már futó program utólagos átmentésére sem alkalmas.

Rendkívül hasznos lehetőség, ha parancsainkat és alkalmazásainkat tetszőleges időpontban, előre ütemezve, netán periodikusan tudjuk végrehajtatni. A standard Unix két parancsa nyújt erre lehetőséget: az at az előre ütemezett, egyszeri parancsvégrehajtást teszi lehetővé, a crontab pedig rendszeresen ismétlődő parancsok indítását végzi. (A legtöbb rendszerben a crontab csak a privilégizált felhasználók számára hozzáférhető, ezért itt nem foglalkozunk vele.)

Az at parancs a következőképpen indítható (a CTRL-D itt is a ténylegesen leütendő vezérlőkaraktert szimbolizálja):

Az alábbi példával azt illusztráljuk, hogy hogyan lehet az éjszakai lemezkihasználtsági állapotokat kilistázni:

Példánkban három parancsot adtunk meg, éjszaka fél egykor történő végrehajtásra, egy echo, egy df és még egy echo parancsot. (A df -k parancs hatására a gép összes állományrendszerének lemezkihasználtságáról kapunk információkat, mekkorák az egyes lemezek, mekkora a foglalt és a szabad részek aránya, mind kilobájtban, mind százalékosan megadva.)

A bemenetet záró CTRL-D megadása után a shell figyelmeztet, hogy az általunk megadott parancs(oka)t egy Bourne shell fogja végrehajtani, végül kilistáz egy azonosítót. Ha a megadott időpontban éppen nem vagyunk bejelentkezve, a program(ok) futásakor kapott esetleges eredményt és a hibaüzeneteket levélben küldi el nekünk.

Természetesen itt is lehet átirányítást használni, így például a végrehajtandó parancsokat egy állományba szerkeszthetjük, s az at parancsot úgy indítjuk, hogy a standard input helyett e fájlból olvasson:

Az időpont megadásakor elég laza szabályok vannak, az at parancs elég intelligens ahhoz, hogy a legtöbb angol időpont- és dátummegadási módot felismerje (megint csak a szerzők tapasztalata, hogy azért azt az egyet éppen nem szeretik, amit mi igen...). Lehetőség van a tomorrow, today, midnight, now stb szavak használatára is. Csak ízelítőül, az alábbiak mind érvényes és használható dátumformátumok:

Arról nem ejtettünk még szót (s ha van az olvasók között olyan, aki szereti rögvest begépelni a példákat, az valószínűleg elátkozott már ezért minket), hogy a legtöbb rendszerben nem mindenkinek engedélyezett az at parancs használata sem. Még pontosabban fogalmazva, alapbeállítás szerint csak a root és egyéb privilégizált felhasználók futtathatnak időzített parancsokat.

A hozzáférések szabályzása két fájl révén történik, az at.allow és az at.deny fájlokkal. (Ezek rendszerint a /usr/spool/cron, vagy a /usr/lib/cron katalógusban találhatóak.) Az előbbibe azokat a felhasználókat lehet beírni, akik használhatják az at parancsot, utóbbiba pedig azokat, akiknél ezt kifejezetten tiltjuk. A megfelelő fájlok üresen hagyásával lehet beállítani a két szélsőséget, miszerint mindenki, illetve senki sem jogosult az időzített parancsvégrehajtásra. E két fájlt természetesen csak privilégizált felhasználók módosíthatják.

Tartalomjegyzék