0

下面的程序由3个并发进程和3个二进制信号量组成，信号量，初始化为S0=1 S1=0 S2=0

进程 P0：

while(1)
{
wait (S0);
print '0';
release (S1);
release (S2);
}

流程 P1：

wait(S1);
release (S0);

过程 P2：

wait(S2);
release (S0);

处理 PO 打印 '0" 多少次？

(A) 至少两次 (b) 正好两次 (c) 正好三次 (d) 正好一次

在此我感到困惑的是，进程 P1 和 P2 将执行一次，或者它们将在执行一次后继续，因为它们没有像进程 P0 那样的 while 循环，如果它们只会执行一次，那么根据我的答案应该是（b） ，如果他们将再次执行，那么答案将是 (A)

请帮助提前谢谢

4

6 回答 6

3

最初P0将执行，因为只有S0=1. 它将打印单个 0。

现在 whenS1和S2are 发布到P0那时它们中的任何一个都可以执行。

让我们假设 P1 执行并释放 S0（现在 S0 的值为 1）。

现在有两种可能P0或者P2可以执行。

让我们P2执行和释放S0，所以最后 P0 执行并打印 0（意味着两个 0），但如果P0在此之前执行，P2则总共会打印 3 个 0（一个在那个时候释放，P0然后再次执行）。P2S0P0

所以完美的答案是至少两个 0。

于 2012-10-05T18:10:48.870 回答
1

解决方案如下：

  1. 只有进程 P0 可以先执行。这是因为进程 P0 使用的信号量，即 S0 的初始值为 1。现在当 P0 调用等待 S0 时，S0 的值变为 0，这意味着 S0 已被 P0 占用。就 Process P1 和 P2 而言，当它们分别在 S1 和 S2 上调用 wait 时，它们无法继续进行，因为信号量已经被初始化为取 0，所以它们必须等到 S1 和 S2 被释放！

  2. P0 首先执行并打印 0。现在下一条语句释放 S1 和 S2！当 S1 被释放时，进程 P1 的等待结束，因为 S1 的值增加了 1 并被标记为未占用。P1 取 S1 并使 S1 为取。过程 P2 也是如此。

  3. 现在，only one of P1 or P2 can execute, because either of them can be in the critical section at a given time.. 假设 P2 执行。它释放 S0 并终止。

  4. 让 P1 执行下一步.. P1 启动 释放 S0 并终止。

  5. Now only P0 can execute because its in a while loop whose condition is set to true, which makes it to run always.P0 执行第二次打印 0 并释放 S1 和 S2。但是 P1 和 P2 已经终止，所以 P0 永远等待 S0 的释放。

这是第二个解决方案，它打印 0 三次：

  1. P0 启动，打印 0 并释放 S1 和 S2。

  2. 让 P2 执行。P2 启动，释放 S0 并终止。此后只有 P0 或 P1 可以执行。

  3. 让 P0 执行。第二次打印 0 并释放 S1 和 S2。此时只有 P1 可以执行。

  4. P1 启动，释放 S0，P1 终止。此时只有 P0 可以执行，因为它在条件设置为 true 的 while 循环中！

  5. P0 启动，第三次打印 0 并释放 S1 和 S2。然后它等待某人释放 S0，而这永远不会发生。

所以答案就变成了正好两倍或正好三次，也可以说是“ atleast twice”！

请告诉我我是否在任何地方错了！！

有关信号量的更多问题，请参阅此

于 2012-10-18T03:44:14.643 回答
0

P0 将首先执行，因为只有 S0=1。因此它将打印 0（第一次）。P0 也释放 S1 和 S2。由于 S1=1 且 S2=1，因此 P1 或 P2，其中任何一个都可以执行。让我们假设 P1 执行并释放 S0（现在 S0 的值 = 1）。请注意，P1 过程已完成。现在 S0=1 和 S2=1，因此 P0 可以执行或 P2 可以执行。让我们检查两个条件：-

  1. 让我们假设 P2 执行，并释放 S0 并完成其执行。现在 P0 执行；S0=0 并打印 0（即第二个 0）。然后释放 S1 和 S2。但请注意，P1 和 P2 进程已经完成了它们的执行。同样，如果 P0 尝试执行，它会因为 S0=0 而进入睡眠状态。因此，打印“0”的最小次数为 2。

  2. 现在，让我们假设 P0 执行。因此 S0=0，（由于等待（S0）），它将打印 0（第二个 0）并释放 S1 和 S2。现在只有 P2 可以执行，因为 P1 已经完成了它的执行，而 P0 因为 S0 = 0 不能执行。现在 P2 执行并释放 S0（即 S0=1）并完成它的执行。现在 P0 开始执行并再次打印 0（第三个 0）并释放 S1 和 S2（注意现在 S0=0）。P1 和 P2 已经完成了它的执行，因此 P1 再次轮到它，但由于 S0=0，它进入睡眠状态。并且可以唤醒 P0 的进程 P1 和 P2 已经执行完毕。因此，“0”被打印的最大次数为 2。

参考： http: //www.btechonline.org/2013/01/gate-questions-os-synchronization.html

于 2013-01-22T10:59:46.550 回答
0

阅读问题和代码我也会说（A）。我假设这些进程在完成任务之前不能被抢占。

它说初始状态是S0=1 S1=0 S2=0，并且根据我们所知道的P1并且P2将执行一次。

并发流程可能很复杂，但是我尝试描述流程，人们会发现我的想法有问题，没关系，我也是来学习的。

现在，您有几种情况会根据流程的顺序产生不同的结果。

P0 -> P1 -> P0 -> P2 -> P0 = Three times

P0 -> P1 -> P2 -> P0 = Twice

P0 -> P2 -> P1 -> P0 = Twice

这给了我们至少两次的答案。

编辑：

所有这一切都是在 wait() 阻塞而 semaphore == 0 并且 release() 设置 semaphore = 1 的假设下进行的，否则代码将主要是疯狂的。

如果过程可以随时中断，那么事情就会变得有趣。

P0 starts out running because S0=1 at start
P0 print '0';
P0 release(S1);
-- here S1 may take over or not --
P0 release(S2);
-- here S2 may take over or not --
P0 goes back to wait(S0)
-- here P0 continues or if S1 *and* S2 have not run blocks --
-- it may also be that only S1 or S2 ran and now the other will run --

现在我试图找出一种方法来可视化事情的结果，但我没有找到一种很好的方法将它放入代码块中。

如果 S1 和 S2 都尽可能快地运行，因为信号量是二进制的并且只能处于两种状态中的一种，P0 只会运行两次，但是如果调度是不正当的，以至于延迟 S1 或 S2 直到 P0 过去wait() 再次 P0 将运行 3 次。

但我认为这个问题并不意味着有可中断的过程，它只是变得混乱。

于 2012-08-22T11:21:24.560 回答
0

我假设 wait() 减少信号量并在它变为 <= 0 时阻塞，而 release 增加计数器并唤醒下一个进程。

给定您的代码， P1 和 P2 执行一次（它们周围没有循环）。这意味着他们每个人都会触发一次 S0。由于 P0 在每次打印之前都在 S0 上等待，因此它最终会打印 '0' 两次。

要检查的另一件事是 S0 的初始状态，因为 P0 只有在 S0 为 0 时才会阻塞。根据您的陈述，情况就是这种情况。因此，答案是 P0 将精确地打印 0两次。

于 2012-08-22T08:48:21.037 回答
0

最初只有 P0 可以进入 while 循环，因为 S0 = 1，S1 = 0，S2 = 0。P0 首先打印 '0'，然后在释放 S1 和 S2 之后，P1 或 P2 将执行并释放 S0。所以 0 再次打印。

于 2015-12-29T17:00:46.827 回答