Blokada odczytu-zapisu

Zaimplementuj blokadę z rozróżnieniem czytelników i zapisujących, wypełniając poniższy szablon pliku rwlock.h:

#ifndef H_RWLOCK
#define H_RWLOCK

#include "futex.h"
#include "xlock.h"
#include "semaphore.h"

struct rwlock
{
    static const int MAX_READERS = 1<<30;

    void lockR()
    {
    }

    void unlockR()
    {
    }

    void lock()
    {
    }

    void unlock()
    {
    }
};

#endif // H_RWLOCK

Metody lock() i unlock() zamykają i otwierają blokadę w trybie zapisu, a lockR() i unlockR() — w trybie czytania. Blokada powinna gwarantować:

1. ekskluzywność dostępu do zapisu: po wywołaniu lock() wszystkie wywołania lock() i lockR() blokują wątek do momentu wywołania unlock().

2. wspólny dostęp do czytania: po wywołaniu lockR() kolejne wywołania lockR() nie blokują wątku (ale patrz następny punkt!).

3. niemożność „głodzenia” zapisującego przez czytelników: po wywołaniu lockR() i (blokującym) lock() dalsze wywołania lockR() powinny blokować wątek do momentu, gdy wątek-zapisujący wywoła unlock().

       4. praca całkowicie w przestrzeni użytkownika przy braku konfliktów: jeśli na blokadę nie pretensjonuje żaden zapisujący,             lub dokładnie jeden zapisujący i żaden czytelnik, wywołania wszystkich metod nie powinny odwoływać się do systemu operacyjnego.

Można założyć, że wywołania lock() i unlock(), a także lockR() i unlockR() będą odpowiednio sparowane w ramach wątków, nie będą używane rekurencyjnie, a liczba wątków, które jednocześnie utrzymują blokadę w trybie czytania, nie przekroczy 2^30.

Oprócz standardowych nagłówków C++17, można użyć plików futex.h, xlock.h oraz semaphore.h, które zawierają odpowiednio implementacje futexa, wyłącznej blokady (analog <mutex>, ale z gwarancją braku zbędnych wywołań systemowych) oraz nieograniczonego semafora.