Concurrency “将处理P0打印多少次”；0"；？_Concurrency_Operating System_Semaphore

Concurrency “将处理P0打印多少次”；0"；？

concurrency operating-system

Concurrency “将处理P0打印多少次”；0"；？,concurrency,operating-system,semaphore,Concurrency,Operating System,Semaphore,以下程序由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); 将处理多少次采购订单打印“0” （A）至少两次（b）正好两次（c）正好三次（d）正好一次在这种情况下，我有一个困惑，即进程P1和P2 as将

以下程序由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);

将处理多少次采购订单打印“0”

（A）至少两次（b）正好两次（c）正好三次（d）正好一次

在这种情况下，我有一个困惑，即进程P1和P2 as将执行一次，或者它们将在执行一次后继续执行，因为它们没有while循环式进程P0，如果它们只执行一次，那么根据我的说法，答案应该是（b），如果它们将再次执行，那么答案将是（a）

请提前感谢

我假设wait（）会减少信号量和块，如果它变成我假设wait（）会减少信号量和块，如果它变成阅读问题和代码，我也会说（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（）阻塞，而信号量=0，并且release（）设置信号量=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将再次运行三次

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

阅读问题和代码，我还要说（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（）阻塞，而信号量=0，并且release（）设置信号量=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 --

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

但我认为这个问题并不是要有可中断的进程，它只是变得很混乱。

最初将执行

P0

，因为只有

S0=1

。它将打印单个0

现在，当

P0

释放

S1

和

S2

时，可以执行其中任何一个

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

现在有两种可能执行

P0

或

P2

让我们以

P2

执行并释放

S0

，因此在P0结束时执行并打印0（表示两个0）但是如果

P0

在

P2

之前执行，则总共将打印3个0（在

P0

时打印一个，然后

P2

释放

S0

所以

P0

再次执行）

因此，完美的答案是至少两个0。