A select is only used with channels. Example A switch is used with concrete types. Example A select will choose multiple valid options at random, while aswitch will go in sequence (and would require a fallthrough to match multiple.) Note that a switch can also go over types for interfaces when used with the keyword … Read more
Block forever. For example, package main import ( “fmt” “time” ) func main() { go forever() select {} // block forever } func forever() { for { fmt.Printf(“%v+\n”, time.Now()) time.Sleep(time.Second) } }
I would spawn 4 worker goroutines that read the tasks from a common channel. Goroutines that are faster than others (because they are scheduled differently or happen to get simple tasks) will receive more task from this channel than others. In addition to that, I would use a sync.WaitGroup to wait for all workers to … Read more
You pretty much listed your options. The answer you’re seeking for depends on how you want to use the values stored in the context. context.Context is an immutable object, “extending” it with a key-value pair is only possible by making a copy of it and adding the new key-value to the copy (which is done … Read more
You may find Go Concurrency Patterns article interesting, especially Bounded parallelism section, it explains the exact pattern you need. You can use channel of empty structs as a limiting guard to control number of concurrent worker goroutines: package main import “fmt” func main() { maxGoroutines := 10 guard := make(chan struct{}, maxGoroutines) for i := … 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
IMO, a coroutine implies supporting of explicit means for transferring control to another coroutine. That is, the programmer programs a coroutine in a way when they decide when a coroutine should suspend execution and pass its control to another coroutine (either by calling it or by returning/exiting (usually called yielding)). Go’s “goroutines” are another thing: … Read more
If a goroutine is blocked, there is no cost involved other than: memory usage slower garbage-collection The costs (in terms of memory and average time to actually start executing a goroutine) are: Go 1.6.2 (April 2016) 32-bit x86 CPU (A10-7850K 4GHz) | Number of goroutines: 100000 | Per goroutine: | Memory: 4536.84 bytes | Time: … Read more
Yes, it’s complicated, But there are a couple of rules of thumb that should make things feel much more straightforward. prefer using formal arguments for the channels you pass to go-routines instead of accessing channels in global scope. You can get more compiler checking this way, and better modularity too. avoid both reading and writing … Read more
Yes, this example is correct. It is important that the wg.Add() happens before the go statement to prevent race conditions. The following would also be correct: func main() { var wg sync.WaitGroup wg.Add(1) go dosomething(200, &wg) wg.Add(1) go dosomething(400, &wg) wg.Add(1) go dosomething(150, &wg) wg.Add(1) go dosomething(600, &wg) wg.Wait() fmt.Println(“Done”) } However, it is rather … Read more