concurrency patterns: round-trip

[matt]

Rob Pike's example in slide http://talks.golang.org/2012/concurrency.slide#38 mentions a round-trip pattern where you block on a read to a channel you have just written into. What are the rules associated with this pattern?

In particular I tried this out and I'm coming unstuck as the go routine that reads from the channel, writes back into it, and then reads its own value out of the channel in the next select body.

I'll try and distil a small example if it helps...

[Kamil Kisiel]

Are you using a buffered channel? If you have an unbuffered channel as in the example then the send should block until another goroutine performs a receive.

[Nate Finch]

Writing to the channel will block until someone reads the value, unless the channel is buffered (rob was using unbuffered channels).

See here: http://play.golang.org/p/wF3hsnH2uf

the key part is this:

// this send on the channel blocks until the worker goroutine reads from it

quit <- "Say goodbye, Joe!"

// the worker goroutine must have already read the quit you sent at this point

// so now we're waiting for the quit message sent *from* the worker goroutine

fmt.Println(<-quit)

[matt]

Thanks that's the bit I'd overlooked, its not buffered. Makes sense.