README
¶
sync-once
sync-once is similar to sync.Once of the standard library.
It also has struct Once but has two additional methods DoForce() and Reset().
why
While writing a web application I needed to reload configurations that were calculated using sync.Once.
But sync.Once provide a single method Do() that executes the function only once.
To get around this I wrote this package.
usage
import (
sync "github.com/admpub/once"
)
func main() {
o := new(sync.Once)
// This will work similar to the Once.Do(f) method of the sync package. The function f is only called once
o.Do(loadConfig())
// To call the function either for the first time or again you need to use the sync.DoForce() method
// This will execute irrespective of weather o.Do() was called earlier or not and mark o (Once) as done.
// Call to o.Do() after o.DoForce() will not execute the function.
o.DoForce(loadConfig())
// To reset o (sync.Once) you need to call the Reset() method.
// This will mark o as not executed but will no call the Do() method. You need to call Do() or DoForce() after this.
// Calls to Do() and DoForce() after this will work as described above.
o.Reset()
}
// load config from a static file or any other operation that is usually performed only once
func loadConfig() {
// Do the work here
}
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func OnceFunc ¶ added in v0.0.2
func OnceFunc(f func()) (func(), func())
OnceFunc returns a function that invokes f only once. The returned function may be called concurrently.
If f panics, the returned function will panic with the same value on every call.
func OnceValue ¶ added in v0.0.2
func OnceValue[T any](f func() T) (func() T, func())
OnceValue returns a function that invokes f only once and returns the value returned by f. The returned function may be called concurrently.
If f panics, the returned function will panic with the same value on every call.
func OnceValues ¶ added in v0.0.2
func OnceValues[T1, T2 any](f func() (T1, T2)) (func() (T1, T2), func())
OnceValues returns a function that invokes f only once and returns the values returned by f. The returned function may be called concurrently.
If f panics, the returned function will panic with the same value on every call.
Types ¶
type Once ¶
type Once struct {
// contains filtered or unexported fields
}
Once is an object that will perform exactly one action.
A Once must not be copied after first use.
In the terminology of the Go memory model, the return from f “synchronizes before” the return from any call of once.Do(f).
func (*Once) Do ¶
func (o *Once) Do(f func())
Do calls the function f if and only if Do is being called for the first time for this instance of Once. In other words, given
var once Once
if once.Do(f) is called multiple times, only the first call will invoke f, even if f has a different value in each invocation. A new instance of Once is required for each function to execute.
Do is intended for initialization that must be run exactly once. Since f is niladic, it may be necessary to use a function literal to capture the arguments to a function to be invoked by Do:
config.once.Do(func() { config.init(filename) })
Because no call to Do returns until the one call to f returns, if f causes Do to be called, it will deadlock.
If f panics, Do considers it to have returned; future calls of Do return without calling f.
Source Files