lock ={0};
publiek:
void acquire_read() {
terwijl (waar) {
int huidige_waarde =lock.load();
if (current_value <0) {// Schrijver wacht, probeer het opnieuw
// Geef de processor op, zodat de schrijver een kans heeft.
// Een meer geavanceerde implementatie zou een condition-variabele kunnen gebruiken.
doorgaan;
} else if (compare_and_swap(&lock, current_value, current_value + 1)) {
pauze; // Leesvergrendeling succesvol verkregen
}
}
}
ongeldig release_read() {
slot--; // Verlaag het aantal lezers. Atomaire decrement is cruciaal.
}
void acquire_write() {
terwijl (waar) {
if (compare_and_swap(&lock, 0, -1)) {// Verkrijg lock als er geen lezers of schrijvers zijn
pauze; // Met succes schrijfvergrendeling verkregen
} anders {
// Blijf proberen tot het succesvol is of geef de wachtstatus aan
doorgaan; // Spin-wait, niet ideaal voor hoge twisten
//Een meer geavanceerde versie kan een condition-variabele gebruiken om te voorkomen dat er druk wordt gewacht.
}
}
}
ongeldig release_write() {
slot =0; // Ontgrendel het slot
}
//Helperfunctie (vervangen door de vergelijking en ruil van uw taal)
bool Compare_and_swap(std::atomic* doel, int verwacht, int gewenst) {
retourdoel->vergelijk_exchange_weak(verwacht, gewenst);
}
};
int hoofd() {
MultipleReaderSingleWriterLock m;
// Voorbeeldgebruik
m.acquire_read();
std::cout <<"Lezer 1 heeft vergrendeling verkregen\n";
m.release_read();
std::cout <<"Lezer 1 heeft vergrendeling vrijgegeven\n";
m.acquire_write();
std::cout <<"Schrijver heeft vergrendeling verkregen\n";
m.release_write();
std::cout <<"Schrijver heeft vergrendeling vrijgegeven\n";
m.acquire_read();
m.acquire_read();
std::cout <<"Lezer 2 en 3 hebben vergrendeling verkregen\n";
m.release_read();
m.release_read();
std::cout <<"Lezer 2 en 3 hebben de vergrendeling vrijgegeven\n";
retour 0;
}
```
Belangrijke overwegingen:
* Spinlocks: De methoden `acquire_write` en `acquire_read` maken gebruik van busy-waiting (spinlocks). Dit is inefficiënt bij grote conflicten. Vervang dit voor productiecode door conditievariabelen of andere synchronisatieprimitieven om verspilling van CPU-cycli te voorkomen.
* Verhongering: Hoewel schrijvers voorrang krijgen, kunnen lezers nog steeds honger lijden als er een continue stroom schrijvers is. Een geavanceerder wachtrijsysteem zou de eerlijkheid kunnen verbeteren.
* Atomische operaties: De juistheid van deze vergrendeling is sterk afhankelijk van de atomiciteit van de bewerkingen 'compare_and_swap' en 'increment/decrement'. Zorg ervoor dat de door u gekozen atomaire operaties de nodige garanties bieden.
* Foutafhandeling: Een robuuste implementatie zou foutafhandeling omvatten (bijvoorbeeld het controleren op retourwaarden van atomaire operaties).
* Schaalbaarheid: Voor scenario's met hoge gelijktijdigheid kunt u geavanceerdere vergrendelingsmechanismen overwegen die zijn ontworpen voor betere schaalbaarheid.
Dit verbeterde voorbeeld biedt een robuustere, maar nog steeds vereenvoudigde, implementatie. Overweeg voor productiesystemen het gebruik van gevestigde bibliotheken of raamwerken die goed geteste en sterk geoptimaliseerde synchronisatieprimitieven bieden. Houd er rekening mee dat synchronisatie complex is en een zorgvuldige afweging van mogelijke raceomstandigheden en prestatieknelpunten vereist.
