读者-作者-作者优先级问题

Question

在《信号灯小书》一书中，第71页，存在以下问题：

写一个读者-作者问题的解决方案，优先考虑作者。也就是说，一旦写入程序到达，在所有写入程序离开系统之前，不应允许任何读卡器进入。

我得出了一个解决方案，但它与书中给出的有点不同。

共享变量：

readSwitch = Lightswitch()
writeSwitch = Lightswitch()
noWriters = Semaphore(1)
noReaders = Semaphore(1)

Semaphore（1）表示初始化为1的信号量，而Lightswitch在本书中的定义如下：

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()

读卡器逻辑：

noReaders.wait()
noReaders.signal()

readSwitch.lock(noWriters)

# critical section for readers

readSwitch.unlock(noWriters)

编写器逻辑：

writeSwitch.lock(noReaders)
noWriters.wait()

# critical section for writers

writeSwitch.unlock(noReaders)
noWriters.signal()

共享变量：

readSwitch = Lightswitch()
writeSwitch = Lightswitch()
noWriters = Semaphore(1)
noReaders = Semaphore(1)

读卡器逻辑：

noReaders.wait()
readSwitch.lock(noWriters)
noReaders.signal()

# critical section for readers

readSwitch.unlock(noWriters)

编写器逻辑：

writeSwitch.lock(noReaders)
noWriters.wait()

# critical section for writers

noWriters.signal()
writeSwitch.unlock(noReaders)

1） 在阅读器逻辑中，在我的解决方案中，noReaders。信号（）紧跟在noReaders之后。等待（）。这里的想法是，noReaders就像一种旋转栅门，允许读者通过，但一到就被作者锁定。

然而，在这本书的解决方案中，noReaders。调用readSwitch后完成signal（）。。

我的订购会产生不正确的行为，有什么原因吗？

2）在编写逻辑中，在我的解决方案中，写witch.unlock（noReaders）在noWriters.signal（）之前。然而，这本书把它们放在相反的顺序。我的订购会产生不正确的行为，有什么原因吗？

我还有一个问题。我可能对这本书的解决方案有些误解。假设发生以下情况：

>

读卡器1获取noReaders（noReaders变为0）

读卡器2在noReaders中等待（noReaders变为-1）

写入程序1在noReaders中等待（noReaders变为-2）

读卡器3在noReaders中等待（noReaders变为-3）

Reader 4在noReaders中等待（noReaders变为-4）

读取器1获取noWriters（noWriters变为0）

读卡器1发出信号noReaders（noReaders变为-3；读卡器2解锁）

读卡器2通过noWriterslightswitch；信号noReaders（noReaders变为-2，读卡器3解锁）

在上述情况下，似乎更多的读者可以继续到达并进入关键部分，尽管作者正在等待。

此外，考虑到读写器正在循环，完成关键部分的读写器可以循环并再次等待noReaders，即使已经有写写写器在等待。

我在这里误解了什么？




Answer 1

匿名用户

使用您的解决方案，以下情况是可能的：

• 一个新的作者出现在WriteSwitch.unlock（noReaders）之后，但出现在noWriters.signal（）
之前
• 新写入器执行写witch.lock（noReaders）
• 读取器执行readSwitch.lock（noWriters），即使有写入器也会进入关键部分。

这本书的解决方案首先唤醒了等待的作家，然后才唤醒了读者。您的解决方案首先唤醒读卡器，还允许读卡器在readSwitch处排队。锁定（noWriters），这样即使有写入程序在等待，它们也可以运行。