Multiple requests for a single computationally expensive resource in Go - go

Question

Looking for a more Go-ish solution to the following:
Say, a server have multiple parallell incoming requests asking for a resource with key key. Since computing this resource is expensive/time consuming, we'd like to ensure that is is computed only once. There are infinitely number of possible keys.
One naíve implementation:
if hasCachedValue(key) {
return cachedValue(key)
}
if somebodyElseWorkingOn(key) {
waitUntilReady(key)
} else {
buildCacheValue(key) // time consuming
}
return cachedValue(key)
So far we have solved this using a shared map[string]chan bool, where the first request inserts the chan for key, and the following requests waits for a close on that chan when the value is ready. To protect the map we use a sync.Mutex, but we have a feeling there is a better and more Go-ish solution.

Answer 1

Use the singleflight package. Declare a package-level variable for the group:
var g singleflight.Group
Use the following code to get the value:
v, err, _ := g.Do(key, func() (interface{}, error) {
if !hasCachedValue(key) {
buildCacheValue(key)
}
return cachedValue(key), nil
})
if err != nil {
// handle error
}
x := v.(valueType) // assert to type returned by cachedValue
// do something with x

Answer 2

Here is a simple code that does what you want. I tested it and it works without problem. The Go race condition checker detects no problem.
type Cache struct {
mtx sync.RWMutex
m map[KeyType]*CacheValue
}
type CacheValue struct {
val *ValueType
mtx sync.Mutex
}
func NewCache() *Cache {
return &Cache{m: make(map[KeyType]*CacheValue)}
}
func (c *Cache) Get(key KeyType) *ValueType {
c.mtx.RLock()
v := c.m[key]
c.mtx.RUnlock()
if v != nil {
v.mtx.Lock()
x := v.val
v.mtx.Unlock()
if x != nil {
return x
}
}
if v == nil {
c.mtx.Lock()
v = c.m[key]
if v == nil {
v = &CacheValue{}
c.m[key] = v
}
c.mtx.Unlock()
}
v.mtx.Lock()
if v.val == nil {
v.val = buildValue(key)
}
v.mtx.Unlock()
return v.val
}

Answer 3

Inspired by the Ping Pong example often used to describe channels, we sat out to try a channel-only approach. A ball keeps the state about keys being generated, and the ball is passed between the requests a shared channel:
import "time"
var table = make(chan map[string]chan bool)
func keeper() {
for {
ball := <- table
table <- ball
}
}
func getResource(key string) {
// Take ball from table
ball := <- table
if wait, ok := ball[key]; ok{
println("Somebody else working on " + key + ", waiting")
table <- ball
<- wait
} else {
println("I will build " + key)
ball[key] = make(chan bool)
// Throw away ball
table <- ball
// Building value
time.Sleep(time.Millisecond * 10)
println("I built value for " + key + "!")
// Clean up ball
ball = <- table
close(ball[key])
delete(ball, key)
table <- ball
}
println("Now value for " + key + " has been built")
}
func main(){
go keeper()
ball := make(map[string]chan bool)
table <- ball
key := "key"
go getResource(key)
go getResource(key)
go getResource(key)
time.Sleep(time.Second)
}