Alai

Az operációs rendszer határozza meg a számítástechnikai élményünket. Ez az első szoftver, amit látunk, amikor bekapcsoljuk a számítógépet, és az utolsó szoftver, amit látunk, amikor kikapcsoljuk a számítógépet. Ez az a szoftver, amely lehetővé teszi az összes általunk használt programot. Az operációs rendszer szervezi és vezérli az asztalunkon és a kezünkben lévő hardvert, a legtöbb felhasználó azonban nem tudja pontosan megmondani, hogy mit is csinál az operációs rendszer.

A HowStuffWorks ezen kiadásában elmondjuk, mit kell tennie egy szoftvernek ahhoz, hogy operációs rendszernek nevezhessük, és megmutatjuk, hogyan működik az operációs rendszer, hogy a hardverek gyűjteményéből hatékony számítástechnikai eszközzé váljon!

A puszta csontok
Nem minden számítógépnek van operációs rendszere. A konyhában lévő mikrohullámú sütőt vezérlő számítógépnek például nincs szüksége operációs rendszerre. Egy sor viszonylag egyszerű feladatot kell végrehajtania, nagyon egyszerű be- és kimeneti módszerekkel (egy billentyűzet és egy LCD-képernyő), valamint egyszerű, soha nem változó hardverrel kell vezérelnie. Egy ilyen számítógép esetében az operációs rendszer csak felesleges csomag lenne, és bonyolultabbá tenné az egészet ott, ahol nincs rá szükség. Ehelyett a mikrohullámú sütőben lévő számítógép egyszerűen mindig egyetlen programot futtat.

A mikrohullámú sütő összetettségét meghaladó számítógépes rendszerek esetében azonban egy operációs rendszer lehet a nagyobb működési hatékonyság és a könnyebb alkalmazásfejlesztés kulcsa. Minden asztali számítógép rendelkezik operációs rendszerrel. A legelterjedtebbek a Windows operációs rendszercsalád, a UNIX operációs rendszercsalád és a Macintosh operációs rendszerek. Több száz egyéb operációs rendszer áll rendelkezésre speciális célú alkalmazásokhoz, beleértve a nagyszámítógépek, a robotika, a gyártás, a valós idejű vezérlőrendszerek stb. számára készült specializációkat.

A legegyszerűbb szinten egy operációs rendszer két dolgot tesz:

• A számítógépes rendszer hardver- és szoftvererőforrásait kezeli. Ezek az erőforrások közé tartoznak például a processzor, a memória, a lemezterület stb.
• Szabályos, konzisztens módot biztosít az alkalmazások számára a hardverrel való bánásmódhoz anélkül, hogy ismernie kellene a hardver minden részletét.

Az első feladat, a hardver- és szoftverforrások kezelése nagyon fontos, mivel a különböző programok és beviteli módszerek versengenek a központi feldolgozóegység (CPU) figyelméért, és saját céljaikhoz memóriát, tárolót és be- és kimeneti (I/O) sávszélességet igényelnek. Ebben a minőségében az operációs rendszer a jó szülő szerepét játssza, gondoskodik arról, hogy minden alkalmazás megkapja a szükséges erőforrásokat, miközben szépen játszik az összes többi alkalmazással, valamint a rendszer korlátozott kapacitását az összes felhasználó és alkalmazás legnagyobb hasznára fordítja.

A második feladat, a konzisztens alkalmazási felület biztosítása különösen fontos, ha egy adott típusú számítógépből egynél több fogja használni az operációs rendszert, vagy ha a számítógépet alkotó hardver bármikor megváltoztatható. Egy konzisztens alkalmazásprogram-interfész (API) lehetővé teszi a szoftverfejlesztő számára, hogy megírjon egy alkalmazást egy számítógépre, és nagy biztonsággal tudja, hogy az egy másik, ugyanolyan típusú számítógépen is futni fog, még akkor is, ha a két gépen eltérő a memória vagy a tárhely mennyisége. Még ha egy adott számítógép egyedi is, az operációs rendszer biztosítani tudja, hogy az alkalmazások továbbra is fussanak, amikor hardverfrissítésekre és -frissítésekre kerül sor, mivel az operációs rendszer és nem az alkalmazás feladata a hardver kezelése és az erőforrások elosztása. A Windows 98 nagyszerű példája az operációs rendszer által biztosított rugalmasságnak. A Windows 98 több ezer gyártó hardverén fut. Több ezer különböző nyomtatót, lemezmeghajtót és speciális perifériát képes bármilyen lehetséges kombinációban elhelyezni.

Az operációs rendszerek széles családján belül általában négy típust különböztetünk meg, amelyeket az általuk vezérelt számítógépek típusa és az általuk támogatott alkalmazások fajtája alapján kategorizálunk. A tágabb kategóriák a következők:

• Valós idejű operációs rendszer (RTOS) – A valós idejű operációs rendszereket gépek, tudományos műszerek és ipari rendszerek vezérlésére használják. Egy RTOS jellemzően nagyon kevés felhasználói felülettel rendelkezik, és nincsenek végfelhasználói segédprogramok, mivel a rendszer egy “lezárt doboz” lesz, amikor használatra leszállítják. Az RTOS nagyon fontos része a számítógép erőforrásainak kezelése, hogy egy adott művelet minden alkalommal pontosan ugyanannyi idő alatt hajtható végre. Egy összetett gépben, ha egy alkatrész gyorsabban mozog csak azért, mert a rendszer erőforrásai rendelkezésre állnak, az ugyanolyan katasztrofális lehet, mintha egyáltalán nem mozogna, mert a rendszer elfoglalt.
• Egyfelhasználós, egyetlen feladat – Ahogy a neve is mutatja, ezt az operációs rendszert úgy tervezték, hogy a számítógépet úgy kezelje, hogy egy felhasználó egyszerre csak egy dolgot tudjon hatékonyan elvégezni. A Palm kéziszámítógépekhez készült Palm OS jó példa a modern egyfelhasználós, egyfeladatos operációs rendszerre.
• Egyfelhasználós, többfeladatos – Ez az a típusú operációs rendszer, amelyet manapság a legtöbben használnak az asztali és hordozható számítógépeken. A Windows 98 és a MacOS is példa olyan operációs rendszerre, amely lehetővé teszi, hogy egyetlen felhasználó egyszerre több programot is működtessen. Például teljesen lehetséges, hogy egy Windows-felhasználó jegyzetet ír egy szövegszerkesztőben, miközben letölt egy fájlt az internetről, miközben egy e-mail üzenet szövegét nyomtatja.
• Többfelhasználós – A többfelhasználós operációs rendszer lehetővé teszi, hogy több különböző felhasználó egyszerre használja ki a számítógép erőforrásait. Az operációs rendszernek gondoskodnia kell arról, hogy a különböző felhasználók igényei kiegyensúlyozottak legyenek, és az általuk használt programok mindegyike elegendő és különálló erőforrással rendelkezzen, hogy az egyik felhasználó problémája ne érintse a felhasználók egész közösségét. A Unix, a VMS és a nagyszámítógépes operációs rendszerek, például az MVS, példák a többfelhasználós operációs rendszerekre.

Itt fontos különbséget tenni a többfelhasználós operációs rendszerek és az egyfelhasználós, hálózatot támogató operációs rendszerek között. A Windows 2000 és a Novell Netware egyenként több száz vagy több ezer hálózati felhasználót támogat, de maguk az operációs rendszerek nem igazi többfelhasználós operációs rendszerek. A Windows 2000 vagy a Netware esetében a rendszergazda az egyetlen “felhasználó”. A hálózati támogatás és a hálózat által lehetővé tett összes távoli felhasználói bejelentkezés az operációs rendszer átfogó tervében egy olyan program, amelyet a rendszergazda felhasználó futtat.

Az operációs rendszerek különböző típusait szem előtt tartva ideje megvizsgálni az operációs rendszer által biztosított alapvető funkciókat.

Ébresztés
A számítógép bekapcsolásakor az első program, amely lefut, általában egy, a számítógép csak olvasható memóriájában (ROM) tárolt utasításkészlet, amely megvizsgálja a rendszer hardverét, hogy meggyőződjön arról, hogy minden megfelelően működik. Ez a bekapcsolási önteszt (POST) ellenőrzi a CPU-t, a memóriát és az alapvető be- és kimeneti rendszereket (BIOS) hibák szempontjából, és az eredményt egy speciális memóriahelyen tárolja. A POST sikeres elvégzése után a ROM-ba betöltött szoftver (néha firmware-nek is nevezik) elkezdi aktiválni a számítógép lemezmeghajtóit. A legtöbb modern számítógépben, amikor a számítógép aktiválja a merevlemez-meghajtót, megtalálja az operációs rendszer első darabját: a bootstrap betöltőt.

A bootstrap loader egy kis program, amelynek egyetlen funkciója van: Betölti az operációs rendszert a memóriába, és lehetővé teszi a működés megkezdését. Legegyszerűbb formájában a bootstrap loader állítja be azokat a kis meghajtóprogramokat, amelyek a számítógép különböző hardveres alrendszereivel kapcsolódnak és azokat vezérlik. Beállítja a memória azon részeit, amelyek az operációs rendszert, a felhasználói információkat és az alkalmazásokat tartalmazzák. Létrehozza azokat az adatstruktúrákat, amelyek a számítógép alrendszerein és alkalmazásain belüli és azok közötti kommunikációhoz használt számtalan jelet, zászlót és szemaforot tartalmaznak. Ezután átadja a számítógép irányítását az operációs rendszernek.

Az operációs rendszer feladatai a legáltalánosabb értelemben hat kategóriába sorolhatók:

• Processzorkezelés
• Memóriakezelés
• Eszközkezelés
• Tároláskezelés
• Alkalmazási felület
• Felhasználói felület

Míg vannak, akik azt állítják, hogy az operációs rendszernek ennél a hat feladatnál többet kell végeznie, és néhány operációs rendszergyártó sokkal több segédprogramot és segédfunkciót épít be operációs rendszerébe, ez a hat feladat határozza meg szinte minden operációs rendszer magját. Nézzük meg, milyen eszközöket használ az operációs rendszer az egyes feladatok elvégzéséhez.

Processzor kezelése
A processzor kezelésének lényege két, egymással összefüggő kérdésre vezethető vissza:

• Az, hogy minden folyamat és alkalmazás elegendő időt kapjon a processzorból a megfelelő működéshez
• A processzor minél több ciklusának felhasználása a valódi munkára

A szoftver alapvető egysége, amellyel az operációs rendszer a processzor által végzett munka ütemezésében foglalkozik, az operációs rendszertől függően egy folyamat vagy egy szál.

Kísértés, hogy egy folyamatra úgy gondoljunk, mint egy alkalmazásra, de ez nem ad teljes képet arról, hogy a folyamatok hogyan viszonyulnak az operációs rendszerhez és a hardverhez. Az Ön által látott alkalmazás (szövegszerkesztő vagy táblázatkezelő vagy játék) valóban egy folyamat, de ez az alkalmazás több más folyamat elindítását is okozhatja, olyan feladatokhoz, mint a más eszközökkel vagy más számítógépekkel való kommunikáció. Számos olyan folyamat is létezik, amely anélkül fut, hogy közvetlen bizonyítékot adna arra, hogy valaha is létezett. A folyamat tehát olyan szoftver, amely valamilyen műveletet hajt végre, és amelyet a felhasználó, más alkalmazások vagy az operációs rendszer vezérelhet.

Az operációs rendszer nem alkalmazásokat, hanem folyamatokat vezérel, és ütemezi a CPU általi végrehajtást. Egy egyfeladatos rendszerben az ütemezés egyszerű. Az operációs rendszer engedélyezi az alkalmazás futásának megkezdését, és csak annyi időre függeszti fel a végrehajtást, amíg a megszakításokkal és a felhasználói bemenettel foglalkozik. A megszakítások olyan speciális jelek, amelyeket hardver vagy szoftver küld a CPU-nak. Olyan, mintha a számítógép valamelyik része hirtelen felemelné a kezét, hogy a CPU figyelmét kérje egy élénk megbeszélésen. Néha az operációs rendszer úgy ütemezi a folyamatok prioritását, hogy a megszakításokat elfedje — vagyis az operációs rendszer figyelmen kívül hagyja az egyes forrásokból érkező megszakításokat, hogy egy adott feladatot a lehető leggyorsabban be lehessen fejezni. Vannak olyan megszakítások (például hibaállapotokból vagy memóriaproblémákból származó megszakítások), amelyek annyira fontosak, hogy nem lehet figyelmen kívül hagyni őket. Ezeket a nem maszkolható megszakításokat (NMI-k) azonnal kezelni kell, függetlenül a többi folyamatban lévő feladattól.

Míg egy egyfeladatos rendszerben a megszakítások némileg bonyolítják a folyamatok végrehajtását, addig egy többfeladatos rendszerben az operációs rendszer feladata sokkal bonyolultabbá válik. Most az operációs rendszernek úgy kell megszerveznie az alkalmazások végrehajtását, hogy azt higgye, hogy egyszerre több dolog is történik. Ez azért bonyolult, mert a CPU egyszerre csak egy dolgot tud csinálni. Ahhoz, hogy azt a látszatot keltse, hogy sok dolog történik egyszerre, az operációs rendszernek másodpercenként több ezer alkalommal kell váltania a különböző folyamatok között. Ez így történik.

• Egy folyamat elfoglal egy bizonyos mennyiségű RAM-ot. A CPU és az operációs rendszer memóriaterületén belüli regisztereket, veremeket és várólistákat is igénybe veszi.
• Mikor két folyamat többfeladatos, az operációs rendszer egy bizonyos számú CPU végrehajtási ciklust oszt ki egy programnak.
• Egy ilyen számú ciklus után az operációs rendszer másolatot készít a folyamatok által használt összes regiszterről, veremről és várólistáról, és megjegyzi azt a pontot, ahol a folyamat szünetet tartott a végrehajtásban.
• Ezután betölti a második folyamat által használt összes regisztert, veremet és várólistát, és bizonyos számú CPU-ciklust engedélyez neki.
• Amikor ezek befejeződtek, másolatot készít a második program által használt összes regiszterről, veremről és várólistáról, és betölti az első programot.

Váltáskor a folyamat nyomon követéséhez szükséges összes információt egy folyamatvezérlő blokknak nevezett adatcsomagban tárolja. A folyamatvezérlő blokk jellemzően a következőket tartalmazza:

• Egy azonosító számot, amely azonosítja a folyamatot
• Mutatókat a program és adatai azon helyeire, ahol a feldolgozás utoljára történt
• Regiszterek tartalma
• A különböző flagek és kapcsolók állapota
• Mutatókat a felső … a folyamathoz szükséges memória alsó és felső határára
• A folyamat által megnyitott fájlok listája
• A folyamat prioritása
• A folyamat által igényelt összes I/O eszköz állapota

A folyamat állapotának változása, például függőből aktívra, vagy felfüggesztettből futóvá, a folyamatvezérlő blokkban lévő információkat ugyanúgy kell használni, mint bármely más program adatait, hogy az operációs rendszer feladatváltó részének végrehajtását irányítsuk.

Ez a folyamatcsere a felhasználó közvetlen beavatkozása nélkül történik, és minden folyamat elegendő CPU-ciklust kap ahhoz, hogy a feladatát ésszerű idő alatt elvégezze. Baj akkor történhet azonban, ha a felhasználó túl sok folyamatot próbál egyszerre működtetni. Magának az operációs rendszernek is szüksége van néhány CPU-ciklusra ahhoz, hogy elvégezze az alkalmazási folyamatok összes regiszterének, várólistájának és halmazának mentését és cseréjét. Ha elég sok folyamat indul, és ha az operációs rendszert nem gondosan tervezték meg, a rendszer elkezdheti a rendelkezésre álló CPU-ciklusok túlnyomó többségét a folyamatok közötti cserére használni ahelyett, hogy folyamatokat futtatna. Amikor ez megtörténik, azt thrashingnek nevezik, és általában valamilyen közvetlen felhasználói beavatkozásra van szükség a folyamatok leállításához és a rendszer rendjének helyreállításához.

Az operációs rendszer tervezői többek között úgy csökkentik a thrashing esélyét, hogy csökkentik a különböző feladatok elvégzéséhez szükséges új folyamatok szükségességét. Egyes operációs rendszerek lehetővé teszik egy “process-lite”, úgynevezett szál létrehozását, amely képes egy normál folyamat összes CPU-intenzív munkáját elvégezni, de általában nem foglalkozik a különböző típusú I/O-val, és nem hoz létre olyan struktúrákat, amelyek egy normál folyamat kiterjedt folyamatvezérlő blokkját igénylik. Egy folyamat számos szálat vagy más folyamatot indíthat, de egy szál nem indíthat folyamatot.

Az eddig tárgyalt ütemezés eddig egyetlen CPU-ra vonatkozott. Egy két vagy több CPU-val rendelkező rendszerben az operációs rendszernek meg kell osztania a munkaterhelést a CPU-k között, megpróbálva egyensúlyt teremteni a szükséges folyamatok igényei és a különböző CPU-kon rendelkezésre álló ciklusok között. Az aszimmetrikus operációs rendszerek egy CPU-t használnak a saját igényeik kielégítésére, az alkalmazási folyamatokat pedig elosztják a többi CPU között. A szimmetrikus operációs rendszerek megosztják magukat a különböző CPU-k között, kiegyensúlyozva az igényeket a CPU-k rendelkezésre állásával szemben, még akkor is, ha csak maga az operációs rendszer fut.

Még ha az operációs rendszer az egyetlen szoftver, amelynek végrehajtási igényei vannak, a CPU nem az egyetlen erőforrás, amelyet ütemezni kell. A memóriakezelés a következő döntő lépés annak biztosításában, hogy minden folyamat zökkenőmentesen fusson.

Memória- és tárolókezelés
Amikor az operációs rendszer kezeli a számítógép memóriáját, két átfogó feladatot kell elvégeznie:

• Minden folyamatnak elegendő memóriával kell rendelkeznie a végrehajtáshoz, és nem futhat bele egy másik folyamat memóriaterületébe, illetve nem futhat bele egy másik folyamat.
• A rendszerben lévő különböző memóriatípusokat megfelelően kell használni, hogy az egyes folyamatok a leghatékonyabban tudjanak futni.

Az első feladathoz az operációs rendszernek memóriahatárokat kell beállítania a szoftvertípusok és az egyes alkalmazások számára.

Példaként nézzünk meg egy képzeletbeli rendszert, amelynek 1 megabájt (1000 kilobájt) RAM-ja van. Képzeletbeli számítógépünk operációs rendszere a rendszerindítás során úgy van kialakítva, hogy a rendelkezésre álló memória tetejéig menjen, majd “visszalépjen” elég messzire, hogy kielégítse magának az operációs rendszernek az igényeit. Tegyük fel, hogy az operációs rendszernek 300 kilobájtra van szüksége a futtatáshoz. Most az operációs rendszer a RAM-állomány aljára megy, és elkezdi felépíteni a számítógép hardveres alrendszereinek vezérléséhez szükséges különféle meghajtószoftvereket. Képzeletbeli számítógépünkben az illesztőprogramok 200 kilobájtot foglalnak el. Miután tehát az operációs rendszer teljesen betöltődött, 500 kilobájt marad az alkalmazási folyamatok számára.

Amikor az alkalmazásokat elkezdik betölteni a memóriába, az operációs rendszer által meghatározott blokkméretekben töltődnek be. Ha a blokkméret 2 kilobájt, akkor minden betöltött folyamat egy olyan memóriarészletet kap, amely a 2 kilobájt többszöröse. Az alkalmazások betöltése ezekben a rögzített blokkméretekben történik, a blokkok a 4 vagy 8 bájtos szavak által meghatározott határokkal kezdődnek és végződnek. Ezek a blokkok és határok segítenek biztosítani, hogy az alkalmazások ne töltődjenek egymás helyére egy-két rosszul kiszámított bittel. Miután ez biztosítva van, a nagyobb kérdés az, hogy mi a teendő, ha az 500 kilobájtos alkalmazási terület betelt.

A legtöbb számítógépen lehetőség van az eredeti kapacitáson túli memória hozzáadására. Például bővíthetjük a RAM-ot 1 megabájtról 2 megabájtra. Ez jól működik, de általában viszonylag drága. Emellett figyelmen kívül hagyja a számítástechnika egy alapvető tényét — a legtöbb információt, amelyet egy alkalmazás a memóriában tárol, egy adott pillanatban nem használja. A processzor egyszerre csak egy helyet tud elérni a memóriában, így a RAM túlnyomó többsége minden pillanatban kihasználatlan. Mivel a lemezterület a RAM-hoz képest olcsó, a RAM-ban lévő információk merevlemezre történő áthelyezésével a RAM-terület költségmentesen nagymértékben bővíthető. Ezt a technikát virtuális memóriakezelésnek nevezik.

A lemezes tárolás csak az egyik olyan memóriatípus, amelyet az operációs rendszernek kell kezelnie, és ez a leglassabb. A sebesség sorrendjében a számítógépes rendszerben található memóriatípusok a következők:

• Nagysebességű gyorsítótár – Ez a gyors, viszonylag kis mennyiségű memória, amely a leggyorsabb kapcsolatokon keresztül áll a CPU rendelkezésére. A gyorsítótár-vezérlők megjósolják, hogy a CPU-nak mely adatdarabokra lesz legközelebb szüksége, és a rendszer teljesítményének felgyorsítása érdekében a főmemóriából a nagysebességű gyorsítótárba húzzák azokat.
• Főmemória – Ez az a RAM, amelyet megabájtokban mérve lát a számítógép vásárlásakor.
• Másodlagos memória – Ez leggyakrabban valamilyen forgó mágneses tároló, amely az alkalmazásokat és az adatokat felhasználásra készen tartja, és virtuális RAM-ként szolgál az operációs rendszer irányítása alatt.

Az operációs rendszernek egyensúlyt kell teremtenie a különböző folyamatok igényei és a különböző típusú memóriák rendelkezésre állása között, blokkokban (úgynevezett oldalakban) mozgatva az adatokat a rendelkezésre álló memória között, ahogy a folyamatok ütemezése diktálja.

Eszközkezelés
Az operációs rendszer és gyakorlatilag minden, nem a számítógép alaplapján lévő hardver közötti út egy speciális programon, az úgynevezett illesztőprogramon keresztül vezet. Az illesztőprogramok feladata nagyrészt az, hogy a hardver alrendszerek elektromos jelei, valamint az operációs rendszer és az alkalmazási programok magas szintű programozási nyelvei közötti fordítóként működjenek. Az illesztőprogramok az operációs rendszer által fájlként meghatározott adatokat átveszik, és lefordítják azokat a tárolóeszközökön meghatározott helyeken elhelyezett bitfolyamokká, vagy egy nyomtatóban lézerimpulzusok sorozatává.

Mivel a meghajtókon keresztül vezérelt hardverek között ilyen nagy különbségek vannak, a meghajtóprogramok működésében is vannak különbségek, de a legtöbbet akkor futtatják, amikor az eszközre szükség van, és nagyjából ugyanúgy működnek, mint bármely más folyamat. Az operációs rendszer gyakran rendel magas prioritású blokkokat az illesztőprogramokhoz, hogy a hardveres erőforrás a lehető leggyorsabban felszabaduljon és készen álljon a további használatra.

Az egyik oka annak, hogy az illesztőprogramok elkülönülnek az operációs rendszertől, az, hogy új funkciókat lehessen hozzáadni az illesztőprogramhoz — és így a hardver alrendszerekhez — anélkül, hogy magát az operációs rendszert módosítani, újrafordítani és újraosztani kellene. Az új hardvereszköz-illesztőprogramok fejlesztésével – a fejlesztést gyakran nem az operációs rendszer kiadója, hanem az alrendszerek gyártója végzi vagy fizeti – a teljes rendszer be- és kimeneti képességei jelentősen javíthatók.

A be- és kimenet kezelése nagyrészt a várólisták és pufferek kezeléséből áll, olyan speciális tárolóeszközökből, amelyek egy eszközről, például egy billentyűzetről vagy egy soros portról bitek folyamát veszik át, ezeket a biteket tárolják, és olyan sebességgel adják ki a CPU-nak, amely elég lassú ahhoz, hogy a CPU megbirkózzon velük. Ez a funkció különösen akkor fontos, ha számos folyamat fut, és a processzor idejét veszi igénybe. Az operációs rendszer utasítja a puffert, hogy továbbra is fogadja a bemenetet az eszközről, de ne küldjön adatokat a CPU-nak, amíg a bemenetet használó folyamat felfüggesztésre kerül. Ezután, amikor a bemenetet igénylő folyamat ismét aktívvá válik, az operációs rendszer utasítja a puffert, hogy küldjön adatokat. Ez az eljárás lehetővé teszi, hogy a billentyűzet vagy a modem nagy sebességgel tudjon foglalkozni a külső felhasználókkal vagy számítógépekkel, még akkor is, ha vannak olyan időszakok, amikor a CPU nem tudja használni az ilyen forrásokból származó bemenetet.

A számítógépes rendszer összes erőforrásának kezelése az operációs rendszer feladatának nagy részét képezi, és a valós idejű operációs rendszerek esetében gyakorlatilag az összes szükséges funkciót jelentheti. Más operációs rendszerek esetében azonban a létezésük okának döntő része, hogy viszonylag egyszerű, konzisztens módot biztosítsanak az alkalmazások és az emberek számára a hardver teljesítményének kihasználására.

Interface to the World

Application Interface
Ahogyan az illesztőprogramok lehetőséget biztosítanak az alkalmazások számára a hardver alrendszereinek használatára anélkül, hogy a hardver működésének minden részletét ismerniük kellene, az alkalmazásprogram-interfészek (API-k) lehetővé teszik az alkalmazásprogramozók számára a számítógép és az operációs rendszer funkcióinak használatát anélkül, hogy közvetlenül nyomon kellene követniük a CPU működésének minden részletét. Nézzük meg az adatok tárolására szolgáló merevlemezfájl létrehozásának példáját, hogy lássuk, miért lehet ez fontos.

A programozó, aki egy tudományos műszer adatainak rögzítésére ír egy alkalmazást, esetleg azt szeretné, ha a tudós megadhatná a létrehozott fájl nevét. Az operációs rendszer biztosíthat egy MakeFile nevű API-funkciót a fájlok létrehozásához. A program írása során a programozó beillesztene egy sor, amely így néz ki:

MakeFile

Ebben a példában az utasítás azt mondja az operációs rendszernek, hogy hozzon létre egy olyan fájlt, amely lehetővé teszi az adatok véletlenszerű elérését (1), a felhasználó által beírt névvel rendelkezik (%Név), és mérete attól függően változik, hogy mennyi adatot tárol a fájlban (2). Most nézzük meg, mit tesz az operációs rendszer, hogy az utasítást tettekre váltsa.

1. Az operációs rendszer lekérdezést küld a lemezmeghajtónak, hogy megtudja az első szabad tárolóhely helyét.
2. Ezzel az információval az operációs rendszer létrehoz egy bejegyzést a fájlrendszerben, amely tartalmazza a fájl kezdő és befejező helyét, a fájl nevét, a fájltípust, azt, hogy a fájl archiválva van-e, hogy mely felhasználóknak van jogosultságuk a fájl megtekintésére vagy módosítására, valamint a fájl létrehozásának dátumát és időpontját.
3. Az operációs rendszer a fájl elejére olyan információkat ír, amelyek azonosítják a fájlt, meghatározzák a lehetséges hozzáférés típusát, és egyéb olyan információkat tartalmaznak, amelyek a fájlt az alkalmazáshoz kötik.

   Az összes ilyen információban a lemezmeghajtóhoz intézett lekérdezések és a fájl kezdő- és végpontjának címei a lemezmeghajtó gyártójától és modelljétől erősen függő formátumban szerepelnek.

Mivel a programozó úgy írta meg a programját, hogy az API-t használja a lemeztároláshoz, nem kell minden lehetséges merevlemez- és szalagos meghajtó utasításkódjaival, adattípusaival és válaszkódjaival lépést tartania. A hardver változó részleteivel az operációs rendszer foglalkozik, amely a különböző hardveralrendszerek meghajtóprogramjaihoz kapcsolódik — a programozónak egyszerűen kódot kell írnia az API-hoz, a többit pedig rábízza az operációs rendszerre.

Az API-k az utóbbi években a számítógépipar egyik leghevesebben vitatott területévé váltak. A vállalatok felismerik, hogy az API-jukat használó programozók végső soron az iparág egy adott részének ellenőrzését és hasznát fogják jelenteni. Ez az egyik oka annak, hogy oly sok vállalat hajlandó volt ingyenesen a nyilvánosság rendelkezésére bocsátani az olyan alkalmazásokat, mint az olvasók vagy a nézők. Tudják, hogy a fogyasztók kérni fogják, hogy a programok használják ki az ingyenes olvasók előnyeit, és az alkalmazással foglalkozó vállalatok készek lesznek jogdíjat fizetni azért, hogy szoftverük a fogyasztók által kért funkciókat nyújthassa.

Használói felület
Mint ahogy az API egységes módot biztosít az alkalmazások számára a számítógépes rendszer erőforrásainak használatára, úgy a felhasználói felület (UI) struktúrát hoz a felhasználó és a számítógép közötti interakcióba. Az elmúlt évtizedben a felhasználói felületek terén szinte minden fejlesztés a grafikus felhasználói felület (GUI) területén történt, és két modell, az Apple Macintosh és a Microsoft Windows kapta a legtöbb figyelmet és szerezte meg a legtöbb piaci részesedést. Más operációs rendszerekhez más felhasználói felületek is léteznek, némelyik grafikus, némelyik nem.

A Unixnak például vannak héjaknak nevezett felhasználói felületei, amelyek rugalmasabb és erőteljesebb felhasználói felületet mutatnak be, mint az operációs rendszer standard, szöveges alapú felülete. Az olyan programok, mint a Korn Shell és a C Shell olyan szövegalapú felületek, amelyek fontos segédprogramokat adnak hozzá, de fő céljuk az, hogy megkönnyítsék a felhasználó számára az operációs rendszer funkcióinak kezelését. Vannak grafikus felhasználói felületek is, mint például az X-Windows és a Gnome, amelyek a felhasználó szemszögéből a Unixot és a Linuxot inkább a Windows és a Macintosh számítógépekhez teszik hasonlóvá.

Nem szabad elfelejteni, hogy mindezekben a példákban a felhasználói felület egy olyan program vagy programkészlet, amely egy rétegként helyezkedik el maga az operációs rendszer felett. Ugyanez igaz – némileg eltérő mechanizmusokkal – a Windows és a Macintosh operációs rendszerekre is. Az operációs rendszer alapvető operációs rendszerfunkciói, a számítógépes rendszer kezelése az operációs rendszer magjában rejlik. A kijelzőkezelő különálló, bár lehet, hogy szorosan kötődik az alatta lévő kernelhez. Az operációs rendszer magja és a felhasználói felület, a segédprogramok és egyéb szoftverek közötti kapcsolatok ma is meghatározzák az operációs rendszerek sok különbségét, és a jövőben is meghatározzák azokat.

A jövő
Az operációs rendszerek jövőjével kapcsolatos egyik kérdés az körül forog, hogy egy bizonyos szoftverterjesztési filozófia képes-e olyan operációs rendszert létrehozni, amelyet a vállalatok és a fogyasztók együttesen használhatnak.

A nyílt forráskód elvei szerint létrehozott és terjesztett operációs rendszer, a Linux jelentős hatással lehet az operációs rendszerekre általában. A legtöbb operációs rendszert, illesztőprogramot és segédprogramot kereskedelmi szervezetek írják, amelyek szoftverük futtatható verzióit terjesztik — olyan verziókat, amelyeket nem lehet tanulmányozni vagy módosítani. A nyílt forráskód megköveteli az eredeti forrásanyagok terjesztését, amelyek tanulmányozhatók, módosíthatók és továbbfejleszthetők, és az eredmények ismét szabadon terjeszthetők.

Az internet folyamatos növekedése és a nem szabványos asztali vagy hordozható számítógépek elterjedése azt jelenti, hogy az operációs rendszerek változni fognak, hogy lépést tartsanak vele, de az alapvető kezelési és interfész funkciók a fejlődésük során is megmaradnak.