我正在用 Go 编写哲学家用餐解决方案。我的解决方案很简单:检查两个 fork 是否可用。如果是这样，请同时选择两者。如果不是，请保留两者。

但是，我遇到了一个奇怪的并发错误，即使在明确设置为 false 之后，fork 的可用性仍然是 true。我的 Fork 声明如下:

type Fork struct {
    mu    sync.Mutex
    avail bool
}

func (f *Fork) PickUp() bool {
    f.mu.Lock()
    if f.avail == false {
        f.mu.Unlock()
        return false
    }
    f.avail = false
    fmt.Println("set false")
    f.mu.Unlock()
    return true
}

func (f *Fork) PutDown() {
    f.mu.Lock()
    f.avail = true
    f.mu.Unlock()
}

当哲学家调用PickUp()时，程序会等待互斥锁；如果此时 fork 可用，则 Fork 将其可用性 bool 值设置为 false 并返回 true 以指示操作成功。

哲学家是这样写的:

type Philosopher struct {
    seatNum int
}

func (phl *Philosopher) StartDining(forkList [9]Fork) {
    for {
        fmt.Println(forkList[phl.seatNum], phl.seatNum)
        if forkList[phl.seatNum].PickUp() {
            fmt.Println("Philo ", phl.seatNum, " picked up fork ", phl.seatNum)

            if forkList[phl.getLeftSpace()].PickUp() { 
                fmt.Println("Philo ", phl.seatNum, " picked up fork ", phl.getLeftSpace())
                fmt.Println("Philo ", phl.seatNum, " has both forks; eating...")
                time.Sleep(5 * time.Second)

                forkList[phl.seatNum].PutDown()
                forkList[phl.getLeftSpace()].PutDown()
                fmt.Println("Philo ", phl.seatNum, " put down forks.")
            } else {
                forkList[phl.seatNum].PutDown()
            }
        }
    }
}

(注意:getLeftSpace() 函数已被排除，因为它的实现无关紧要；它只是获取左侧空间的索引。)

Philosopher 的实现非常简单:它检查是否可以获得第一个 fork 。然后，它检查是否可以得到第二个 fork ；如果不能，它会放下第一个 fork 。如果可以，它会保持 5 秒钟，然后放下。出于测试目的，我将此限制为两位哲学家。

但是，这无法正常工作。哲学家 0 拿起第一把 fork ，然后拿起第二把 fork 。我已验证这些 fork 的可用性已设置为 false。至此，Philosopher 1 被互斥锁锁定。然而，一旦 Philo 0 释放了互斥量，Philo 1 就进入了这个函数。

此时的预期结果是 PickUp() 函数返回 false；由于 fork 不再可用，因此无法拿起。但是，该功能不会这样做；它返回 true 并允许 Philo 1 拿起 fork !

更神秘的是，当 Philo 1 去拿起 fork 时， fork 的可用性是 true，即使 Philo 0 明确地将它们设置为 false!这是我的调试输出:

{{0 0} true} 0                       # Fork 0 is available
set false                            # Fork 0 has been picked up
Philo  0  picked up fork  0          # Repsonse from Philo 0 confirming the above
{{0 0} true} 0                       # Fork 1 is available
set false                            # Fork 1 has been picked up
Philo  0  picked up fork  1          # Response from Philo 0 confirming the above
Philo  0  has both forks; eating...  # As Philo 0 has both forks, they can now eat...

{{0 0} true} 1                     **# Philo 1 checks Fork 0's availability, **which is true?**
set false                            # Philo 1 sets Fork 0's availability to false
Philo  1  picked up fork  1          # Response of ^
{{0 0} true} 1                       
set false                            
Philo  1  picked up fork  2
Philo  1  has both forks; eating...

Philo 1 应该永远无法拿起 fork 。由于 Philo 1 被互斥锁锁定，PickUp 的唯一两个退出条件是在可用性为 false 之后， fork 不可能可用。

但确实如此。为什么是这样？我该如何解决这个问题？

最佳答案

我认为问题几乎可以肯定是您的 StartDining 方法的签名:

func (phl *Philosopher) StartDining(forkList [9]Fork)

Go 中的数组按值传递，因此每次调用 StartDining 时，您都会传递 fork 的副本。哲学家们在完全不同的 table 上用餐!

尝试传入一个指向数组的指针。

关于concurrency - 为什么并发写入的boolean值设置为false后还是true？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18040143/