I have a case where I am reading data from 2 different locations (ES and REDIS), I need to read a single value from the fastest source, thus I am firing 2 goroutines, one to get the data from ES, the other to get it from REDIS.
once data has been fetched from one of the goroutines, the other goroutine must be canceled completely not to waste CPU.
simplified:
func A(){
go funcB(){
}()
go funcC(){
}()
data := <-channel //
}
now once the data is received, funcA or funcB must be canceled, no matter what they were doing (I don't care for their output anymore, they are just wasting CPU)
what would be the most efficient way to do it? can it be done using channels only?
The context package provides cancelation, timeout and deadline contexts for this purpose. Here you can see a cancelation example, and we wait for the slower goroutine to print the cancelled message:
ctx, cancel := context.WithCancel(context.Background())
// buffer the channel for extra results returned before cancelation
data := make(chan string, 2)
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
select {
case <-time.After(100 * time.Millisecond):
data <- "A complete"
case <-ctx.Done():
fmt.Println("A cancelled")
}
}()
wg.Add(1)
go func() {
defer wg.Done()
select {
case <-time.After(200 * time.Millisecond):
data <- "B complete"
case <-ctx.Done():
fmt.Println("B cancelled")
}
}()
resp := <-data
cancel()
fmt.Println(resp)
wg.Wait()