Monitor - a programozási nyelvekben a folyamatok interakciójának és szinkronizálásának magas szintű mechanizmusa, amely hozzáférést biztosít a megosztott erőforrásokhoz. [1] Megközelítés két vagy több számítógépes feladat szinkronizálására egy közös erőforrás, általában hardver vagy változók segítségével .
A monitor alapú többfeladatos munkavégzés során a fordító vagy értelmező transzparensen illeszti be a zár-feloldó kódot a megfelelően formázott rutinokba, transzparens módon a programozó számára, megkímélve a programozót attól, hogy kifejezetten szinkronizációs primitíveket hívjon.
Per Brinch Hansen volt az első, aki leírta és implementálta a monitorokat Hoare ötletei alapján . Ezt követően Hoare kidolgozta az elméleti keretet, és megmutatta a szemaforokkal való egyenértékűségét (az eredeti szemantika felhasználásával). Először a Concurrent Pascal nyelvben testesült meg, és a folyamatok közötti kommunikáció strukturálására használták a Solo operációs rendszerben .
A monitor a következőkből áll:
A monitorozási eljárás a munka megkezdése előtt felveszi a mutexet, és addig tartja, amíg az eljárás ki nem fejeződik, vagy amíg egy feltételt nem vár (lásd alább). Ha minden egyes eljárás garantálja, hogy az invariáns igaz a mutex feloldása előtt, akkor egyetlen feladat sem szerezheti meg az erőforrást versenyhelyzetben.
Egy egyszerű példa. Fontolja meg a bankszámla-tranzakciókat végrehajtó monitort.
számla figyelése { int egyensúly := 0 function visszavon( int összeg) { if summa < 0 then error "A számla nem lehet negatív" else if egyenleg < összeg then hiba "Pénzhiány" else egyenleg := egyenleg - összeg } function befizetés( int összeg) { if summa < 0 then error "Az összeg nem lehet negatív" else egyenleg := egyenleg + összeg } }Az invariáns itt egyszerűen azt állítja, hogy az egyenlegnek tükröznie kell az összes múltbeli tranzakciót, mielőtt egy új tranzakció elkezdődik. Ez általában nincs kódban kifejezve, hanem hallgatólagos, és megemlíthető a megjegyzésekben . Vannak azonban olyan programozási nyelvek, mint például az Eiffel vagy a D , amelyek képesek ellenőrizni az invariánsokat. A zárat a fordító adja hozzá. Ez biztonságosabbá és kényelmesebbé teszi a monitorokat, mint más módszerek, amelyek megkövetelik, hogy a programozó kézzel adja hozzá a zárolás-feloldó műveleteket, mert előfordulhat, hogy a programozó elfelejti hozzáadni azokat.
Az aktív várakozási állapot elkerülése érdekében a folyamatoknak jelezniük kell egymást a várható eseményekről. A monitorok ezt a lehetőséget feltételváltozókon keresztül biztosítják . Ha egy megfigyelési eljárásnak egy bizonyos feltételnek teljesülnie kell a folytatáshoz, akkor a kapcsolódó feltételváltozóra vár. Várakozás közben ideiglenesen feloldja a mutexet, és kikerül a futó folyamatok listájából. Minden olyan folyamat, amely ezt követően a feltétel teljesülését okozza, a feltétel változót használja a várakozási folyamat értesítésére. A bejelentett folyamat visszaszerzi a mutexet, és folytatódhat.
A következő figyelő feltételváltozókat használ a folyamatok közötti csatorna megvalósítására, amely egyszerre csak egy egész értéket tárolhat.
figyelési csatorna { int tartalom logikai érték teljes := false feltétel snd feltétel rcv function send( int message) { while full do wait(rcv) // Mesa szemantika: lásd alább tartalom := üzenet tele := igaz értesít(snd) } function Receive() { var int fogadott while not full do wait(snd) // Mesa szemantika: lásd alább kapott := tartalom tele := hamis értesít (rcv) visszaérkezett } }Vegye figyelembe, hogy mivel egy feltételre várva feloldja a zárolást, a várakozási folyamatnak biztosítania kell, hogy az invariáns teljesüljön a várakozás megkezdése előtt. A fenti példában ugyanez igaz a riasztásra is.
A korai figyelési implementációkban ( Hoare szemantikaként ismert ) a feltételváltozó értesítése azonnal felébreszti a várakozási folyamatot, és visszaállítja a zárolást, így biztosítva, hogy a feltétel továbbra is igaz.
Ennek a viselkedésnek a megvalósítása bonyolult és nagyon redundáns. Ezenkívül nem kompatibilis a megelőző többfeladatos kezeléssel , ahol a folyamat tetszőleges pillanatban megszakítható. Ezen okok miatt a kutatók sok más szemantikát is kidolgoztak a feltételváltozókra.
A legmodernebb implementációkban ( Mesa szemantika néven ) az értesítés nem szakít meg egy futó folyamatot, hanem egyszerűen kész állapotba helyez néhány várakozási folyamatot. Az értesítési folyamat mindaddig megtartja a zárat, amíg az ki nem lép a figyelési eljárásból. Ennek a megközelítésnek az a mellékhatása, hogy az értesítési folyamatnak nem kell megfigyelnie a bejelentés előtti invariánst, hanem a várakozási folyamatnak újra kell ellenőriznie a várt állapotot. Különösen, ha a megfigyelési eljárás tartalmaz egy kifejezést , egy másik folyamat beléphet a figyelőbe az értesítési pillanat után, és megváltoztathatja az értéket , mielőtt a várakozási folyamat folytatódna. A kifejezést így kell átírni: így a feltétel a várakozás után újra ellenőrzésre kerül. if test then wait(cv)testwhile test do wait(cv)
Az implementációk egy "notifyAll" vagy "broadcast" műveletet is biztosítanak, amely értesíti az összes folyamatot, amely egy adott feltételre vár. Ez a művelet például akkor hasznos, ha több folyamat vár arra, hogy különböző mennyiségű memória álljon rendelkezésre. A memória felszabadítása lehetővé teszi, hogy az egyik továbbra is működjön, de az ütemező nem tudja, melyik.
Példa egy feltételváltozó megvalósítására:
conditionVariable { int queueSize = 0; mutex zár; szemafor várakozás; várjon() { lock.acquire(); queueSize++; lock.release(); várakozás.lefelé(); } jel() { lock.acquire(); while (queueSize > 0){ queueSize--; vár.fel(); } lock.release(); } }Monitorokat támogató programozási nyelvek: