Vitajte na [www.pocitac.win] Pripojiť k domovskej stránke Obľúbené stránky
1. Štruktúra a implementácia:
* semafory:
* jednoduché celé premenné: V ich jadre sú semafory celočíselné premenné, ku ktorým je prístup k atómovým operáciám upravené a upravené.
* Dve atómové operácie: Zvyčajne majú dve primárne operácie:
* `wait ()` (alebo `p ()` alebo `acvare ()`):znížte hodnotu semaforu. Ak sa hodnota stane zápornou, proces/vlákno sa blokuje, kým hodnota semaforu nebude väčšia alebo rovná nule.
* `signál ()` (alebo `v ()` alebo `release ()`):zvyšuje hodnotu semaforu. Ak na semafor čakajú blokované procesy/vlákna, jeden z nich je odblokovaný.
* Žiadne implicitné združenie údajov: Semafory vo svojej podstate viažu mechanizmus synchronizácie na akékoľvek konkrétne údaje. Na riadenie prístupu k akémukoľvek zdieľanému zdroju môžete použiť semafor, ale musíte spravovať asociáciu manuálne.
* monitory:
* Štruktúrovaný prístup: Monitory sú štruktúrovanejšie programovacie konštrukty. Zapuzdajú:
* Zdieľané údaje: Premenné predstavujúce chránené zdieľané prostriedky.
* Postupy/metódy: Operácie, ktoré majú prístup k zdieľaným údajom a upravujú. Toto sú jediné rutiny, ktoré môžu priamo získať prístup k zdieľaným údajom.
* premenné podmienky: (Dôležité!) Špeciálne premenné používané na signalizáciu a čakanie v rámci monitora.
* Explicitné vzájomné vylúčenie: Monitory poskytujú implicitné vzájomné vylúčenie. Iba jedno vlákno/proces môže byť aktívny * vo vnútri * monitor v ktoromkoľvek danom čase. Toto vzájomné vylúčenie je automaticky presadzované samotným monitorom.
2. Presadzovanie vzájomného vylúčenia:
* semafory:
* manuálne presadzovanie: Semafores sa spolieha na programátorov, aby správne používali `wait ()` a `signál ()„ Operácie okolo kritických sekcií. Je na programátorovi, aby sa zabezpečilo, že vzájomné vylúčenie je správne udržiavané. Chyby je možné ľahko zaviesť. Napríklad zabudnutie na `signál ()` môže viesť k uviaznutiu. Umiestnenie `wait ()` alebo `signál ()` mimo zamýšľanej kritickej časti môže spôsobiť problémy so súbežnosťou.
* Chyba náchylná: Toto manuálne presadzovanie je náchylné na chyby. Je ľahké urobiť chyby, ktoré prelomia vzájomné vylúčenie alebo spôsobujú patových zámkov.
* monitory:
* implicitné presadzovanie: Monitory presadzujú vzájomné vylúčenie *implicitne *. Jazyk/systém zaisťuje, že vo vnútri monitora môže byť aktívne iba jedno vlákno. To uľahčuje rozum a menej náchylné na chyby. Kompilátor alebo systém runtime zvláda blokovanie a odomknutie.
3. Synchronizácia stavu (čakanie a signalizácia):
* semafory:
* Všeobecné, ale menej štruktúrované na čakanie na podmienky: Semafores * sa dá použiť na synchronizáciu stavu (napr. Čakanie na sprístupnenie zdroja). Je to však trochu ťažkopádne. Zvyčajne potrebujete samostatné semafory na vzájomné vylúčenie a pre signalizačné podmienky, vďaka čomu je kód zložitejší a náchylný k chybe. Môžete použiť počítanie semaforov na označenie toho, koľko zdrojov je k dispozícii.
* monitory:
* premenné podmienky: Monitory používajú * premenné podmienky * špecificky pre synchronizáciu stavu. Poskytujú operácie ako:
* `počkajte (podmienka)`:Volajúce vlákno uvoľňuje zámok monitora a čaká na zadanú „podmienku“. Vlákno je umiestnené vo fronte spojenej s touto premennou stavu. Zámok monitora sa uvoľní, takže ďalšie vlákna môžu vstúpiť do monitora.
* `Signál (podmienka)`:Jedno vlákno čakanie na zadanú „podmienku“ sa prebudí. Signalizované vlákno znovu získava zámok monitora.
* `Broadcast (podmienka)` (alebo `SignalAll (podmienka)`):prebudí všetky vlákna čakajúce na zadanú `podmienku".
* Vylepšená štruktúra: Premenné podmienky sú úzko spojené s monitorom a jeho zdieľanými údajmi, čo uľahčuje porozumenie a rozum o synchronizácii stavu v monitore.
4. Vlastníctvo a zodpovednosť:
* semafory:
* Žiadne jasné vlastníctvo: Akékoľvek vlákno môže `počkať ()` alebo `signál ()` na semaforu. Neexistuje koncept „vlastníctva“ semaforu.
* monitory:
* jasné vlastníctvo: Vlákna musia zadať monitor (implicitne získať zámok monitora) pred prístupom k zdieľaným údajom alebo premenným stavu signalizačnej podmienky. To presadzuje jasný model vlastníctva.
5. Reentrance:
* semafory:
* Žiadny inherentný koncept reentrancie: Semafory nevie, či vlákno volá `wait ()` alebo `signál ()` už obsahuje semafor. Použitie semaforu reentrantne (napr. Rovnaké vlákno získava semafor viackrát bez toho, aby ho uvoľnilo) môže ľahko viesť k zablokovaniu.
* monitory:
* Všeobecne nereentrant: Monitory sú zvyčajne navrhnuté tak, aby neboli reentrantmi *. Vlákno, ktoré už drží zámok monitora, nemôže monitor znovu vstúpiť. Toto zjednodušuje zdôvodnenie stavu programu, ale niekedy si môže vyžadovať reštrukturalizačný kód. Niektoré implementácie monitorov podporujú Reentrance, ale je to menej bežné.
v súhrne:
| Funkcia | Semafory Monitory
| ------------------- | --------------------------------------------------- | --------------------------------------------------------------- |
| Štruktúra Jednoduché celočíselné premenné Štruktúrovaný konštrukt s údajmi, postupmi a premennými stavu
| Vzájomné vylúčenie Manuál (zodpovednosť za programátor) Implicitné (vynútené samotným monitorom)
| Synchronizácia stavu Môže byť použitý, ale menej štruktúrovaný Explicitné s premennými stavu (čakanie, signál, vysielanie)
| Chyba náchylná | Viac náchylných na chyby kvôli manuálnej správe Menej náchylné na chyby v dôsledku implicitného presadzovania
| Vlastníctvo Žiadne jasné vlastníctvo Jasné vlastníctvo (vlákno musí zadať monitor) |
| Reentrance | Všeobecne sa nezohľadňuje Všeobecne neregistrované |
Kedy použiť ktoré:
* semafory: Aj keď sú stále cenné, semafory sa často považujú za primitívny na nižšej úrovni. Sú užitočné, keď je potrebný jednoduchý mechanizmus počítania alebo keď sú požiadavky na synchronizáciu veľmi základné. Pomáhajú tiež v systémoch, v ktorých monitory nie sú natívne podporované.
* monitory: Monitory sú uprednostňované pri riešení zložitejších scenárov synchronizácie. Ich štruktúrovaný prístup, implicitné vzájomné vylúčenie a premenné podmienok uľahčujú písanie a udržiavateľný súbežný kód. Monitory sú vhodné na ochranu zdieľaných dátových štruktúr a implementáciu synchronizačných vzorcov. Mnoho moderných programovacích jazykov poskytuje vstavanú podporu pre monitory alebo podobné konštrukty (napr. Java's `Synchronized` kľúčové slovo a` wait () `,` notify () `,` notifyAll () `metódy alebo Pythonov` `noading.lock` a` vlákno.condition ").
Príklad (koncepčný - nie špecifický jazyk):
SEMAPHORE PRÍKLAD (Konceptuálne):
`` `
semafor mutex =1; // Binárny semafor pre vzájomné vylúčenie
semafor resourceAvailable =0; // Počítanie semaforu pre dostupné zdroje
// vlákno 1 (výrobca)
počkajte (mutex);
// prístup a upravte zdieľaný prostriedok
// Pridať zdroj
signál (mutex);
signál (resourceAvavaily); // Signal, že zdroj je teraz k dispozícii
// vlákno 2 (spotrebiteľ)
počkajte (ResourceAvavaily); // Počkajte, kým bude k dispozícii zdroj
počkajte (mutex);
// prístup a upravte zdieľaný prostriedok
// konzumujte zdroj
signál (mutex);
`` `
Monitor príklad (konceptuálny):
`` `
Monitor myMonitor {
Zdieľané údaje:...;
podmienky obnoviteľné;
metóda AccessResource () {
// implicitne získajte zámok monitora
zatiaľ čo (zdroj nie je k dispozícii) {
počkajte (ResourceAvavaily); // Uvoľnite monitor, počkajte na podmienku
}
// prístup a upravte zdieľané údaje
// ...
signál (resourceAvavaily); // čakacie vlákno signálu
// implicitne uvoľnite zámok monitora, keď sa metóda vráti
}
metóda addResource () {
// implicitne získajte zámok monitora
// Pridajte zdroj do zdieľaných údajov
signál (resourceAvavaily); // čakacie vlákno signálu
// implicitne uvoľnite monitorový zámok
}
}
`` `
V príklade monitora je vzájomné vylúčenie automaticky riešené monitorom, čo je menej náchylné na chyby. Premenné podmienky poskytujú štruktúrovanejší spôsob zvládania čakania a signalizácie v porovnaní s použitím semaforov priamo na tento účel.