I was reading some go code and say a few different ways to pass go channels. Maybe they are the same but I was wondering if there is any difference since I couldn't find documentation online:
1)
func serve(ch <-chan interface{}){ //do stuff }
2)
func serve(ch chan<- interface{}){ //do stuff }
3)
func serve(ch chan interface{}){ //do stuff }
4)
func server(ch *chan interface{}){ //do stuff}
I was wondering what the difference between them were and if they were just equivalent ways to do the same thing: pass a channel around different goroutines.
NOTE: I am aware that there is no reason to pass a pointer to a chan, map, or slice, or function value, since those are all reference types which internally contain a pointer (the exception would be if you want the callee to change the reference type header). The only reason I provided it is for completeness (i.e. to really provide every way a channel could be attempted to be passed as a parameter and to make on question that hopefully, references all ways to do this and compares them).
Are channels implicitly passed by reference in go ? Yes, the reference types in Go are slice , map and channel . When passing these, you're making a copy of the reference. (Strings are also implemented as a reference type, though they're immutable.)
In order to be able to run the goroutines until the finish, we can either make use of a channel that will act as a blocker or we can use waitGroups that Go's sync package provides us with.
Go channels are used for communicating between concurrently running functions by sending and receiving a specific element type's data. When we have numerous Goroutines running at the same time, channels are the most convenient way for them to communicate with one another.
Buffered channels allows to accept a limited number of values without a corresponding receiver for those values. It is possible to create a channel with a buffe. Buffered channel are blocked only when the buffer is full. Similarly receiving from a buffered channel are blocked only when the buffer will be empty.
I always recommend that the direction is passed everywhere it is possible, e.g.
func serve(ch <-chan SomeType) { /*do stuff*/ } func serve(ch chan<- SomeType) { /*do stuff*/ }
By including the arrow <-chan
or chan<-
, you are achieving three things:
chan<-
is the sending (writing) end. <-chan
is the receiving (reading) end.These are good reasons to show the channel end whenever possible.
Your third case depicts not specifying the end of the channel. This allows both ends of the channel to be accessed, which will be correct in some cases but in other cases may lead to accidental errors.
The fourth case, passing a pointer to a channel, is quite unusual and perhaps a bit odd. If you wanted to change the channel, it would be clearer to include it as a return parameter instead.
The rule of thumb: Arrow shows if the data is going into (output) or going out of (input) channel. No arrow is general purpose channel.
chan <- writing to channel (output channel) <- chan reading from channel (input channel) chan read from or write to channel (input/output channel)
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With