The only non-blocking operation I know of to read from a channel is inside a select block having a default case : select { case x, ok := <-ch: if ok { fmt.Printf(“Value %d was read.\n”, x) } else { fmt.Println(“Channel closed!”) } default: fmt.Println(“No value ready, moving on.”) } Please try the non-blocking here … Read more
This famous quote can be a little bit confusing if taken too litterally. Let’s break it down to its more basic components, and define them properly: Don’t communicate by sharing memory; share memory by communicating —- 1 —- —— 2 —– —- 3 —– —– 4 —– This means that different threads of execution would … Read more
I think you have several issues with initial understanding. Frankly, I’m a bit surprised to see the following: both need 5 threads to handle the volume. How did you identify you need that exact number? Do you have any guarantees 5 threads will be enough? RabbitMQ is tuned and time tested, so it is all … Read more
You can use the select statement with a default. In case it is not possible to do any of the cases, like sending to a full channel, the statement will do the default: package main import “fmt” func main() { ch := make(chan int, 1) // Fill it up ch <- 1 select { case … Read more
Both will work indeed. But one will be more constraining. The form with the arrow pointing away from the chan keyword means that the returned channel will only be able to be pulled from by client code. No pushing allowed : the pushing will be done by the random number generator function. Conversely, there’s a … Read more
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: You are making it clear that the parameter is one end of a channel. … Read more
Independently of the correctness of your second example (as explained in the comments, you aren’t doing what you think, but it’s easily fixable), I tend to think that the first example is easier to grasp. Now, I wouldn’t even say that channels are more idiomatic. Channels being a signature feature of the Go language shouldn’t … Read more
The source file for channels is (from your go source code root) in /src/pkg/runtime/chan.go. hchan is the central data structure for a channel, with send and receive linked lists (holding a pointer to their goroutine and the data element) and a closed flag. There’s a Lock embedded structure that is defined in runtime2.go and that … Read more
It can use either. By default, preference is given to UDP, but depending on the firewall(s) in between the peers connecting it may only be able to connect with TCP. You can use Wireshark to capture packets and verify whether TCP or UDP is being used. In Chrome you can also see details on the … Read more
The buffer size is the number of elements that can be sent to the channel without the send blocking. By default, a channel has a buffer size of 0 (you get this with make(chan int)). This means that every single send will block until another goroutine receives from the channel. A channel of buffer size … Read more