How to syncronize slow calculation and cache it?

In a golang backend I want to serve a value to a multiple clients, lets call it score. Score is changing with time, and its calculation is slow. Calculation does not depend on previous results. When there are no clients I dont want to calculate it at all. So calculation should happen only on request. But also there is another fact - score cannot change within 5 seconds period. So i tried different aproaches and everything has its drawbacks:

1. Does expensive calculation in absense of clients:

var score interface{}

// run in a separate goroutine
func calculateScorePeriodically() {
	for{
		select{
		case <-time.After(5*time.Second):
			score = calculateScoreExpensiveAndSlow()
		}
	}
}

func serveScore(w http.ResponseWriter, r* http.Request) {
    b, _ := json.Marshal(score)
	w.Write(b)
}

2. Blocks all clients for a long calculation period (but actually may just serve old data to them). And you cannot move if outside a mutex, because then multiple client may enter calculation block simultaneously and would do calculation not within 5 seconds interval but sequentially:

var (
	score interface{}
	mutex sync.Mutex
	updatedAt time.Time
)

func getCachedScore() float64 {
	mutex.Lock()
	defer mutex.Unlock()
	currentTime := time.Now()
	if currentTime.Sub(updatedAt) < 5*time.Second {
		return score
	}
	updatedAt = currentTime
	score = calculateScoreExpensiveAndSlow()
	return score
}

func serveScore(w http.ResponseWriter, r* http.Request) {
    b, _ := json.Marshal(getCachedScore())
	w.Write(b)
}

How to solve both of above drawbacks?

PS. i think this is a generic problem, and a pattern - does it have a special name?

There may be multiple solutions. A simple solution is to have a designated goroutine for calculation, to which you can signal a need for recalculation by sending a value on a channel. The send may be non-blocking, so if a calculation is in progress, nothing will happen.

Here's a reusable cache implementation:

type cache struct {
	mu      sync.RWMutex
	value   interface{}
	updated time.Time

	calcCh     chan struct{}
	expiration time.Duration
}

func NewCache(calc func() interface{}, expiration time.Duration) *cache {
	c := &cache{
		value:   calc(),
		updated: time.Now(),
		calcCh:  make(chan struct{}),
	}

	go func() {
		for range c.calcCh {
			v := calc()

			c.mu.Lock()
			c.value, c.updated = v, time.Now()
			c.mu.Unlock()
		}
	}()

	return c
}

func (c *cache) Get() (value interface{}, updated time.Time) {
	c.mu.RLock()
	value, updated = c.value, c.updated
	c.mu.RUnlock()

	if time.Since(updated) > c.expiration {
		// Trigger a new calculation (will happen in another goroutine).
		// Do non-blocking send, if a calculation is in progress,
        // this will have no effect
		select {
		case c.calcCh <- struct{}{}:
		default:
		}
	}

	return
}

func (c *cache) Stop() {
	close(c.calcCh)
}

Note: Cache.Stop() is to stop the background goroutine. After calling Cache.Stop(), Cache.Get() must not be called.

Using it for your case:

func getCachedScore() interface{} {
    // ...
}

var scoreCache = NewCache(getCachedScore, 5*time.Second)

func serveScore(w http.ResponseWriter, r* http.Request) {
    score, _ := scoreCache.Get()
    b, _ := json.Marshal(score)
    w.Write(b)
}

This is what i've implemented, correlates with icza's answer, but has some more features:

package common
import (
"context"
"sync/atomic"
"time"
)
type (
CachedUpdater func() interface{}
ChanStruct    chan struct{}
)
type Cached struct {
value        atomic.Value  // holds the cached value's interface{}
updatedAt    atomic.Value  // holds time.Time, time when last update sequence was started at
updatePeriod time.Duration // controls minimal anount of time between updates
needUpdate   ChanStruct
}
//cachedUpdater is a user-provided function with long expensive calculation, that gets current state
func MakeCached(ctx context.Context, updatePeriod time.Duration, cachedUpdater CachedUpdater) *Cached {
v := &Cached{
updatePeriod: updatePeriod,
needUpdate:   make(ChanStruct),
}
//v.updatedAt.Store(time.Time{}) // "was never updated", but time should never be nil interface
v.doUpdate(time.Now(), cachedUpdater)
go v.updaterController(ctx, cachedUpdater)
return v
}
//client will get cached value immediately, and optionally may trigger an update, if value is outdated
func (v *Cached) Get() interface{} {
if v.IsExpired(time.Now()) {
v.RequestUpdate()
}
return v.value.Load()
}
//updateController goroutine can be terminated both by cancelling context, provided to maker, or by closing chan
func (v *Cached) Stop() {
close(v.needUpdate)
}
//returns true if value is outdated and updater function was likely not called yet
func (v *Cached) IsExpired(currentTime time.Time) bool {
updatedAt := v.updatedAt.Load().(time.Time)
return currentTime.Sub(updatedAt) > v.updatePeriod
}
//requests updaterController to perform update, using non-blocking send to unbuffered chan. controller can decide not to update in case if it has recently updated value
func (v *Cached) RequestUpdate() bool {
select {
case v.needUpdate <- struct{}{}:
return true
default:
return false
}
}
func (v *Cached) updaterController(ctx context.Context, cachedUpdater CachedUpdater) {
for {
select {
case <-ctx.Done():
return
case _, ok := <-v.needUpdate:
if !ok {
return
}
currentTime := time.Now()
if !v.IsExpired(currentTime) {
continue
}
v.doUpdate(currentTime, cachedUpdater)
}
}
}
func (v *Cached) doUpdate(currentTime time.Time, cachedUpdater CachedUpdater) {
v.updatedAt.Store(currentTime)
v.value.Store(cachedUpdater())
}