From the documentation : If the channel is unbuffered, the sender blocks until the receiver has received the value. If the channel has a buffer, the sender blocks only until the value has been copied to the buffer; if the buffer is full, this means waiting until some receiver has retrieved a value. Said otherwise … Read more
If you’re trying to synchronize a pool of workers (e.g. allow n goroutines to crunch away at some amount of work) then channels are a very good way to go about it, but if all you actually need is a counter (e.g page views) then they are overkill. The sync and sync/atomic packages are there … Read more
If a goroutine is blocking, the runtime will start a new OS thread to handle the other goroutines until the blocking one stops blocking. Reference : https://groups.google.com/forum/#!topic/golang-nuts/2IdA34yR8gQ
Technically they’re copied, because when you use make, you are allocating something on the heap, so it’s technically a pointer behind the scenes. But the pointer type is not exposed, so they can be thought of as a reference type. EDIT: From the spec: The built-in function make takes a type T, which must be … Read more
Can someone explain in an easy to understand way the concept of cache miss and its probable opposite (cache hit)? A cache miss, generally, is when something is looked up in the cache and is not found – the cache did not contain the item being looked up. The cache hit is when you look … 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
I would give Erlang a try. Even though it will be a steeper learning curve, you will get more out of it since you will be learning a functional programming language. Also, since Erlang is specifically designed to create reliable, highly concurrent systems, you will learn plenty about creating highly scalable services at the same … Read more
A functional language doesn’t (in general) rely on mutating a variable. Because of this, we don’t have to protect the “shared state” of a variable, because the value is fixed. This in turn avoids the majority of the hoop jumping that traditional languages have to go through to implement an algorithm across processors or machines. … Read more
Note: As of Go 1.5, GOMAXPROCS is set to the number of cores of the hardware: golang.org/doc/go1.5#runtime, below the original answer before 1.5. When you run Go program without specifying GOMAXPROCS environment variable, Go goroutines are scheduled for execution in single OS thread. However, to make program appear to be multithreaded (that’s what goroutines are … Read more
For performance gains modern CPUs often execute instructions out of order to make maximum use of the available silicon (including memory read/writes). Because the hardware enforces instructions integrity you never notice this in a single thread of execution. However for multiple threads or environments with volatile memory (memory mapped I/O for example) this can lead … Read more