I've had a situation where I needed to stream blocks of data from a remote computer in soft-realtime, but still needed to share the same data with many different consumers.
The code was simple, but effective (Go):
import "sync"
type Muxer[T any] struct {
ret T
mut sync.RWMutex
}
func (c *Muxer[T]) Multiplex(fn func() T) (ret T) {
if c.mut.TryLock() {
defer c.mut.Unlock()
ret = fn()
c.ret = ret
} else {
c.mut.RLock()
defer c.mut.RUnlock()
ret = c.ret
}
return ret
}
The way to use it is to write a non-concurrent nullary get() function, then pass it to the Multiplex() function in as many goroutines as needed:
get := func() DataType { ... }
muxer := Muxer[DataType]{}
// in other goroutines
value := muxer.Multiplex(get)
The value will be shared across all goroutines, so we get minimum latency with minimum copying.
I don't get it. It seems overengineered to me, but I can't formulate my reasoning well enough.
Why isn't the original value that you're returning protected by a RWLock, and all goroutines will just need to acquire a read lock, instead of using a write lock for what is basically a getter function?
1) If no other goroutine is currently executing the Multiplex() function, then Multiplex() acquires a write lock, executes the getter and caches the result.
2) If some other goroutine is currently executing the Multiplex() function, then Multiplex() waits to acquire the read lock, then reads the cached value.
So in case of a single goroutine executing the Multiplex() function in a loop, it will be nothing more than a wrapper. But when many goroutines are executing the same Multiplex() function concurrently, only one goroutine will actually execute the getter, and all others will just wait for the first one to finish, then take its cached result.
The point is that you don't have to think about who executes the getter and who copies the cached values, how often to execute the getter, how much time will getter take... You just call it like an ordinary function, and every goroutine will get the most recent value it can get.
Hopefully this clears things out. I'm willing to elaborate further if you have any more questions.
The code was simple, but effective (Go):
The way to use it is to write a non-concurrent nullary get() function, then pass it to the Multiplex() function in as many goroutines as needed: The value will be shared across all goroutines, so we get minimum latency with minimum copying.