原文： 
To begin, consider N computers, each engaged in a process which, for our aims, can be regarded as cyclic. In each of the cycles a so-cMled "critical section" occurs and the computers have to be programmed in such a way that at any moment only one of these N cyclic processes is in its critical section. In order to effectuate this mutual exclusion of critical-section execution the computers can communicate with each other via a common store. Writing a word into or nondestructively reading a word from this store are undividable operations; i.e., when two or more computers try to communicate (either for reading or for writing) simultaneously with the same common location, these communications will take place one after the other, but in an unknown order.

译文：
假设有N个计算机，每个计算机内部都有一个进程，方便起见，可以认为这些进程都是在不断地循环执行一段逻辑。在每个执行周期内都有一个“critical-section”，需要以某种方式对这些计算机进行编程，以确保任意时刻这个N个进程中只有一个会处于“critical-section”。为了实现临界区的互斥执行，这些计算机相互之间可以通过一个共享存储模块进行通信。针对该存储模块的一个以word为单位的读写操作可以认为是原子的，比如当有两个或更多的计算机试图同时读写同一个存储单元时，这些操作会以未知顺序依次完成。

原文：
(a) The solution must be symmetrical between the N computers; as a result we are not allowed to introduce a static priority. 
(b) Nothing may be assumed about the relative speeds of the N computers; we may not even assume their speeds to be constant in time. 
(c) If any of the computers is stopped well outside its critical section, this is not allowed to lead to potential blocking of the others. 
(d) If more than one computer is about to enter its critical section, it must be impossible to devise for them such finite speeds, that the decision to determine which one of them will enter its critical section first is postponed until eternity. In other words, constructions in which "After you"-"After you"-blocking is still possible, although improbable, are not to be regarded as valid solutions.

译文：
(a) 解决方案必须在 N 台计算机之间对称；因此，我们不允许引入静态优先级。
(b) 不得对 N 台计算机的相对速度做任何假设；我们甚至不能假设它们的速度随时间保持不变。
(c) 如果任何一台计算机在远超出其临界区的位置停止运行，则不允许导致其他计算机发生潜在的阻塞。
(d) 如果多台计算机即将进入其临界区，则必须不可能为它们设计出如此有限的速度，以至于决定哪台计算机首先进入临界区的决定被无限期地推迟。换句话说，即使“你之后”-“你之后”阻塞的可能性很小，但这种构造仍然不能被视为有效的解决方案。

// 所有进程共享的内存
var b [N + 1]bool
var c [N + 1]bool
var k int

func init() {
    // 所有布尔值初始为 true
    for i := 1; i <= N; i++ {
        b[i] = true
        c[i] = true
    }

    // k 的初始值只要在 1～N 范围内即可
    k = 1
}

// 第 i 个进程执行的程序
func process(i int) {
    var j int

L0:
    // 我准备竞争临界区
    b[i] = false

L1:
    // 当前候选者不是自己
    if k != i {
        // 暂时退出最终竞争状态
        c[i] = true

        // 如果当前候选者 k 没有参与竞争，
        // 则把自己设置为新的候选者
        if b[k] == true {
            k = i
        }

        // 重新检查候选者
        goto L1
    }

    // 当前候选者已经是自己
    c[i] = false

    // 检查是否还有其他进程处于最终竞争状态
    for j = 1; j <= N; j++ {
        if j != i && c[j] == false {
            goto L1
        }
    }

    // 只有通过上面的检查，才能进入临界区
    criticalSection(i)

    // 离开临界区，恢复初始状态
    c[i] = true
    b[i] = true

    // 非临界区。
    // 进程允许在这里暂停或停止，不会阻塞其他计算机。
    remainderSection(i)

    goto L0
}

原文：
We start by observing that the solution is safe in the sense that no two computers can be in their critical sectionsimultaneously. For the only way to enter its critical section is the performance of the compound statement L14 without jumping back to L11, i.e., finding all other c's true after having set its own c to false.

The second part of the proof must show that no infinite "After you" - "After you" - blocking can occur; i.e., when none of the computers is in its critical section, of the computers looping (i.e., jumping back to L11) at least one - and therefore exactly one - will be allowed to enter its critical section in due time.

If the kth computer is not among the looping ones, b[k] will be true and the looping ones will all find k ≠ i. As a result one or more of them will find in L23 the Boolean b[k] true and therefore one or more will decide to assign "k := i". After the first assignment "k := i", b[k] becomes false and no new computers can decide again to assign a new value to k. When all decided assignments to k have been performed, k will point to one of the looping computers and will not change its value for the time being, i.e., until b[k] becomes true, viz., until the kth computer has completed its critical section. As soon as the value of k does not change any more, the kth computer will wait (via the compound statement L14) until all other c's are true, but this situation will certainly arise, if not already present, because all other looping ones are forced to set their c true, as they will find k ≠ i. And this, the author believes, completes the proof.

译文：
首先，我们观察到该解决方案是安全的，因为没有两台计算机能够同时处于临界区。进入临界区的唯一方法是执行复合语句 L14，而不跳回 L11，也就是说，在将自身的 c 设置为 false 之后，找到所有其他 c 都为 true。

证明的第二部分必须表明不会出现无限的“你之后”-“你之后”阻塞；也就是说，当没有计算机处于临界区时，在循环的计算机（即跳回 L11）中，至少有一台（因此恰好有一台）会在适当的时候进入临界区。

如果第 k 台计算机不在循环的计算机之列，则 b[k] 为 true，并且所有循环的计算机都会发现 k ≠ i。因此，其中一台或多台计算机会在 L23 中发现布尔值 b[k] 为 true，因此其中一台或多台计算机会决定赋值“k := i”。在第一次赋值“k := i”之后，b[k]变为假，此时没有新的计算机可以再次决定为k赋值。当所有已决定的k赋值都执行完毕后，k将指向某个循环计算机，并且暂时不会改变其值，直到b[k]变为真，也就是直到第k台计算机完成其临界区。一旦k的值不再改变，第k台计算机将等待（通过复合语句L14），直到所有其他c都为真。这种情况必然会出现（如果尚未出现），因为所有其他循环计算机都被迫将其c设置为真，因为它们会发现k ≠ i。作者认为，这便完成了证明。

b[]：谁还在参与竞争
k  ：当前优先让谁尝试进入
c[]：谁已经进入最终检查阶段

所有想进入临界区的进程
|  
| b[i] = false
v  
第一阶段：争夺候选资格 k 
|  
| k == i
v  
第二阶段：设置 c[i] = false，检查其他 c[j]
|  
| 所有其他 c[j] 都为 true  
v  
进入临界区

Safety：不能有两个进程同时进入临界区
Progress：不能所有进程都一直竞争，但始终没有人进入临界区