dongtangu8615
2018-11-22 20:45
浏览 48
已采纳

对这些并发的golang问题感到困惑

I just finished the "Concurrency in go" course on coursera(https://www.coursera.org/learn/golang-concurrency/) and I really struggled with the last assignments. This is my submission:

// 1.There should be 5 philosophers sharing chopsticks, with one chopstick between each adjacent pair of philosophers.
// 2.Each philosopher should eat only 3 times (not in an infinite loop as we did in lecture)
// 3.The philosophers pick up the chopsticks in any order, not lowest-numbered first (which we did in lecture).
// 4.In order to eat, a philosopher must get permission from a host which executes in its own goroutine.
// 5.The host allows no more than 2 philosophers to eat concurrently.
// 6.Each philosopher is numbered, 1 through 5.
// 7.When a philosopher starts eating (after it has obtained necessary locks) it prints “starting to eat <number>” on a line by itself, where <number> is the number of the philosopher.
// 8.When a philosopher finishes eating (before it has released its locks) it prints “finishing eating <number>” on a line by itself, where <number> is the number of the philosopher.
package main

import (
    "fmt"
    "sync"
)

var eating = make(chan int, 2)

var mu sync.RWMutex
var everyoneAte int
var timesEaten = make(map[int]int, 5)

type chopstick struct {
    sync.Mutex
}

type philosopher struct {
    leftCs  *chopstick
    rightCs *chopstick
}

func alreadyAte(index int) bool {
    mu.Lock()
    defer mu.Unlock()
    if timesEaten[index] == 3 {
        return true
    }
    return false
}
func (p philosopher) eat(index int) {

    eating <- 1

    p.leftCs.Lock()
    p.rightCs.Lock()

    fmt.Printf("Starting to eat %v
", index)
    fmt.Printf("Finishing eating %v
", index)
    mu.Lock()
    timesEaten[index]++
    if timesEaten[index] == 3 {
        everyoneAte++
    }
    mu.Unlock()
    p.rightCs.Unlock()
    p.leftCs.Unlock()
    <-eating
}

func main() {
    count := 5
    chopsticks := make([]*chopstick, count)
    for i := 0; i < count; i++ {
        chopsticks[i] = &chopstick{}
    }

    philosophers := make([]*philosopher, count)
    for i := 0; i < count; i++ {
        philosophers[i] = &philosopher{
            leftCs:  chopsticks[i],
            rightCs: chopsticks[(i+1)%count],
        }
    }
    for {
        mu.RLock()
        if everyoneAte == count {
            return
        }
        for i := 0; i < count; i++ {
            if timesEaten[i] == 3 {
                continue
            }
            go philosophers[i].eat(i + 1)
        }
        mu.RUnlock()
    }

}

I did not understand how to implement #4 so I just used a buffered channel instead

  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

1条回答 默认 最新

  • doukezi4576 2018-11-23 03:46
    已采纳

    Here is the sequence where philosophers might eat more than three times

    Assume philosopher_1 has eaten 2 times

    1. main: acquires RLock
    2. main: reads timesEaten[1] == 2
    3. main: makes philosopher_1 eat on a separate goroutine_1
    4. main: releases RLock
    5. main: acquires RLock
    6. main: reads timesEaten[1] == 2
    7. main: makes philosopher_1 eat again on a separate goroutine_2
    8. main: releases RLock
    9. goroutine_1: acquires Lock
    10. goroutine_1: sets timesEaten[1] = 3
    11. goroutine_1: releases Lock
    12. goroutine_2: acquires Lock
    13. goroutine_2: sets timesEaten[1] = 4 <-- philosopher_1 ate more than 3 times
    14. goroutine_2: releases Lock
    已采纳该答案
    打赏 评论

相关推荐 更多相似问题