c := make(chan Message)
// Buffering removes a block in main4() loop, when 'true' is send to
// 'wait' channel. Thus, next message will first arrive from the guy, who
- // slept less. Without buffering, main4() will wait until slower guy
- // awakes from 'Sleep' and read 'wait' channel, so the Ann will almost
- // always be the first one.
+ // slept less.
+ //
+ // Without buffering in wait channel main4() will wait until _the first_
+ // spoke guy awakes from 'Sleep' (or the last - this depends on the order
+ // of sending to wait channel statements in main4(), see comment there
+ // too). Thus, even if second guy has woken up from sleep long ago, he's
+ // forced to wait until the first guy wakes up too. Moreover the second
+ // guy always receives its "unblock" signal in wait channel _after_ the
+ // first guy. All these means, that without buffering the order of
+ // messages in bursts will be the same as in first burst most of the time.
waitForIt := make(chan bool, 2)
+ //waitForIt := make(chan bool)
go func() {
for i := 0; ; i++ {
r := rand.Intn(1e3)
}
func main4() {
- c := fanIn4s(boring4("Joe"), boring4("Ann"))
+ //c := fanIn4s(boring4("Joe"), boring4("Ann"))
+ c := fanIn4(boring4("Joe"), boring4("Ann"))
for i := 0; i < 5; i++ {
msg1 := <-c; fmt.Println(msg1.str)
msg2 := <-c; fmt.Println(msg2.str)
+ // Reversing the order in which i "permit speakers to go on", results
+ // in interleaving order of messages: in the first burst Ann's message
+ // was last, thus it'll be the first one in the second burst. And in
+ // the second burst Joey's message was last, thus it'll be the first
+ // in the third burst. And in the third burst Ann's message was last,
+ // thus it'll be first in forth burst, etc.
msg1.wait <- true
msg2.wait <- true
}
func main() {
rand.Seed(time.Now().Unix())
- main9()
+ main4()
}