0

I'm learning about goroutines and channels and have a question about what happens if multiple goroutines try fetching data from the same channel.

How does the go runtime makes sure that data in a channel that is being read by multiple goroutines is provided to only one of the goroutines waiting on the channel and not duplicated or sent to multiple goroutines.

Does the go runtime prevent race conditions when there are multiple goroutines trying to fetch data from the exact same channel? Is there some kind of ordering as to which of the waiting goroutines is given the data for instance First Come First Served?

Richard Chambers
  • 16,643
  • 4
  • 81
  • 106
Vipul Kumar
  • 259
  • 1
  • 2
  • 12
  • 3
    It can never happen that a value is read multiple times from a channel (not even by multiple goroutines). The channel / runtime itself make sure of that. How? For that you will have to dig into how that is implemented in Go. – TehSphinX Jan 21 '21 at 17:51
  • Thank you everyone for your inputs. I was really curious to know which concurrency model (sync using locks or CSP) does go uses to prevent race conditions for multiple goroutines that are fetching data from the same channel. – Vipul Kumar Jan 22 '21 at 07:39
  • @VipulKumar, CSP is a higher level concept than what is used to implement it. The go memory model describes the expectations precisely, but the source is the only reference for how the memory model is implemented. – JimB Jan 22 '21 at 13:45

2 Answers2

2

Channels are one of the primary ways for goroutines to synchronize with each other. Therefore they contain a mechanism to ensure that only one goroutine at a time is able to pull a data item from a channel and that the data item retrieved is not duplicated.

You can't really count on any particular sequence of multiple goroutines reading successfully from the same channel as which specific goroutine's read will complete depends on the multi-threading algorithm used.

See this discussion, Goroutines are cooperatively scheduled. Does that mean that goroutines that don't yield execution will cause goroutines to run one by one?

You can depend on if multiple goroutines are reading from the same channel. Then when there is data in the channel to be read, one of those goroutines will succeed in its read and the data read will not be read by any of the other goroutines that are waiting on a read from the channel to succeed.

See Concurrency from golang-book.com which explains concurrency and goroutines and channels.

See as well How to use channels to safely synchronise data in Go.

See as well this answer which describes using channels rather than a synchronization primitive such as a mutex to maintain a dynamic list of listeners: https://stackoverflow.com/a/18897083/1466970

See also this long and somewhat exhausting description of Anatomy of Channels in Go - Concurrency in Go.

Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Richard Chambers
  • 16,643
  • 4
  • 81
  • 106
0

There is a quite good analysis of Go channel internals here https://codeburst.io/diving-deep-into-the-golang-channels-549fd4ed21a8
Basically, the channel maintains an internal queue of goroutines waiting for the read operations. And when something is sent, it just selects one goroutine from that queue and feeds it with data. If there is no one waiting - data goes into a buffer or blocks the writer.

Spi1y
  • 92
  • 6