互斥问题

Question

请看一下下面的伪代码：

boolean blocked[2];
int turn;
void P(int id) {
      while(true) {
             blocked[id] = true;
             while(turn != id) {
                    while(blocked[1-id])
                    /* do nothing */;
                    turn = id;
             }
             /* critical section */
             blocked[id] = false;
             /* remainder */
      }
}
void main() {
      blocked[0] = false;
      blocked[1] = false;
      turn = 0;
      parbegin(P(0), P(1)); //RUN P0 and P1 parallel
}

我认为可以使用上面的代码实现一个简单的互斥解决方案。但这不起作用。有谁知道为什么吗？

任何帮助将不胜感激！

Answer 1

在这个例子中，由于以下原因，不能保证互斥：

我们从以下情况开始：

blocked = {false, false};
turn = 0;

P1 现在正在执行，并跳过

  blocked[id] = false; // Not yet executed.

现在的情况：

blocked {false, true}
turn = 0;

现在 P0 正在执行。它通过了第二个 while 循环，准备执行关键部分。而当P1执行时，将turn设置为1，也准备好执行临界区。

顺便说一句，这种方法最初是由海曼发明的。 1966 年，他将其发送给 ACM Communications

Answer 2

在本例中，由于以下原因，无法保证互斥：

我们从以下情况开始：

turn= 1;
blocked = {false, false};

执行运行如下：

P0: while (true) {
P0:   blocked[0] = true;
P0:   while (turn != 0) {
P0:     while (blocked[1]) {
P0:     }
P1: while (true) {
P1:   blocked[1] = true;
P1:   while (turn != 1) {
P1:   }
P1:   criticalSection(P1);
P0:     turn = 0;
P0:   while (turn != 0)
P0:   }
P0:   critcalSection(P0);

Answer 3

这是作业，还是一些嵌入式平台？是否有任何原因不能使用 pthreads 或 Win32（相关）同步原语？

Answer 4

也许您需要声明为阻塞并转为易失性，但如果不指定编程语言，则无法知道。

Answer 5

并发不能这样实现，特别是在多处理器（或多核）环境中：不同的核/处理器有不同的缓存。这些缓存可能不一致。下面的伪代码可以按所示顺序执行，并显示结果：

get blocked[0] -> false   // cpu 0
set blocked[0] = true     // cpu 1 (stored in CPU 1's L1 cache)
get blocked[0] -> false   // cpu 0 (retrieved from CPU 0's L1 cache)
get glocked[0] -> false   // cpu 2 (retrieved from main memory)

您需要硬件知识来实现​​并发。

Answer 6

编译器可能已经优化了“空”while 循环。将变量声明为 volatile 可能会有所帮助，但不能保证在多处理器系统上足够。