Ytukyg

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 %vn", index)

    fmt.Printf("Finishing eating %vn", 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 🤷‍♂️

I don't understand why after returning, some philosophers have eaten more than 3 times 🙃

If everyone has answers to those questions, I would appreciate it. I've already submitted the assignment.

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