Readers-writers problem with writer priority - concurrency

Question

Problem
In the book "Little Book of Semaphores", p. 71, there is the following problem:
Write a solution to the readers-writers problem that gives priority to writers. That is, once a writer arrives, no readers should be allowed to enter until all writers have left the system.
I arrived at a solution, but it's a bit different from the one given in the book.
My solution
Shared variables:
readSwitch = Lightswitch()
writeSwitch = Lightswitch()
noWriters = Semaphore(1)
noReaders = Semaphore(1)
Semaphore(1) means a semaphore initialized to 1, and Lightswitch is defined in the book like this:
class Lightswitch:
def __init__(self):
self.counter = 0
self.mutex = Semaphore(1)
def lock(self, semaphore):
self.mutex.wait()
self.counter += 1
if self.counter == 1:
semaphore.wait()
self.mutex.signal()
def unlock(self, semaphore):
self.mutex.wait()
self.counter -= 1
if self.counter == 0:
semaphore.signal()
self.mutex.signal()
Reader logic:
noReaders.wait()
noReaders.signal()
readSwitch.lock(noWriters)
# critical section for readers
readSwitch.unlock(noWriters)
Writer logic:
writeSwitch.lock(noReaders)
noWriters.wait()
# critical section for writers
writeSwitch.unlock(noReaders)
noWriters.signal()
Book's solution
Shared variables:
readSwitch = Lightswitch()
writeSwitch = Lightswitch()
noWriters = Semaphore(1)
noReaders = Semaphore(1)
Reader logic:
noReaders.wait()
readSwitch.lock(noWriters)
noReaders.signal()
# critical section for readers
readSwitch.unlock(noWriters)
Writer logic:
writeSwitch.lock(noReaders)
noWriters.wait()
# critical section for writers
noWriters.signal()
writeSwitch.unlock(noReaders)
Questions
1) In the reader logic, in my solution, noReaders.signal() immediately follows noReaders.wait(). The idea here is that noReaders behaves as a kind of turnstile that allows the readers to pass through it, but is locked by a writer as soon as one arrives.
However, in the book's solution, noReaders.signal() is done after calling readSwitch.lock(noWriters).
Is there any reason why my ordering would produce an incorrect behavior?
2) In the writer logic, in my solution, writeSwitch.unlock(noReaders) comes before noWriters.signal(). However, the book places them in the reverse order. Is there any reason why my ordering would produce an incorrect behavior?
Edit: additional question
I have an additional question. There is something that I am probably misunderstanding about the book's solution. Let's say that the following happens:
Reader 1 acquires noReaders (noReaders becomes 0)
Reader 2 waits in noReaders (noReaders becomes -1)
Writer 1 waits in noReaders (noReaders becomes -2)
Reader 3 waits in noReaders (noReaders becomes -3)
Reader 4 waits in noReaders (noReaders becomes -4)
Reader 1 acquires noWriters (noWriters becomes 0)
Reader 1 signals noReaders (noReaders becomes -3; Reader 2 gets unblocked)
Reader 2 passes through noWriters lightswitch; signals noReaders (noReaders becomes -2,
Reader 3 gets unblocked)
In the above situation, it seems that additional readers can keep arriving and entering the critical section although a writer is waiting.
Besides, considering that reader and writer are looping, a reader that finished the critical section could loop around and wait on noReaders again, even if there are writers already waiting.
What am I misunderstanding here?

Answer 1

With your solution, the following situation is possible:
A new writer comes after writeSwitch.unlock(noReaders) but before noWriters.signal()
New writer executes writeSwitch.lock(noReaders)
A reader executes readSwitch.lock(noWriters), going into critical section even if there is a writer.
The book's solution wakes up waiting writers first before waking up the readers. Your solution wakes up readers first, and also allows readers to queue up at readSwitch.lock(noWriters) so they can run even if there is a writer waiting.