rename sharedcalls to singleflight (#1017)

core/syncx/resourcemanager.go

@@ -9,16 +9,16 @@ import (
 
 // A ResourceManager is a manager that used to manage resources.
 type ResourceManager struct {
-	resources   map[string]io.Closer
-	sharedCalls SharedCalls
-	lock        sync.RWMutex
+	resources    map[string]io.Closer
+	singleFlight SingleFlight
+	lock         sync.RWMutex
 }
 
 // NewResourceManager returns a ResourceManager.
 func NewResourceManager() *ResourceManager {
 	return &ResourceManager{
-		resources:   make(map[string]io.Closer),
-		sharedCalls: NewSharedCalls(),
+		resources:    make(map[string]io.Closer),
+		singleFlight: NewSingleFlight(),
 	}
 }
 
@@ -39,7 +39,7 @@ func (manager *ResourceManager) Close() error {
 
 // GetResource returns the resource associated with given key.
 func (manager *ResourceManager) GetResource(key string, create func() (io.Closer, error)) (io.Closer, error) {
-	val, err := manager.sharedCalls.Do(key, func() (interface{}, error) {
+	val, err := manager.singleFlight.Do(key, func() (interface{}, error) {
 		manager.lock.RLock()
 		resource, ok := manager.resources[key]
 		manager.lock.RUnlock()

core/syncx/singleflight.go

@@ -3,13 +3,17 @@ package syncx
 import "sync"
 
 type (
-	// SharedCalls lets the concurrent calls with the same key to share the call result.
+	// SharedCalls is an alias of SingleFlight.
+	// Deprecated: use SingleFlight.
+	SharedCalls = SingleFlight
+
+	// SingleFlight lets the concurrent calls with the same key to share the call result.
 	// For example, A called F, before it's done, B called F. Then B would not execute F,
 	// and shared the result returned by F which called by A.
 	// The calls with the same key are dependent, concurrent calls share the returned values.
 	// A ------->calls F with key<------------------->returns val
 	// B --------------------->calls F with key------>returns val
-	SharedCalls interface {
+	SingleFlight interface {
 		Do(key string, fn func() (interface{}, error)) (interface{}, error)
 		DoEx(key string, fn func() (interface{}, error)) (interface{}, bool, error)
 	}
@@ -20,20 +24,26 @@ type (
 		err error
 	}
 
-	sharedGroup struct {
+	flightGroup struct {
 		calls map[string]*call
 		lock  sync.Mutex
 	}
 )
 
-// NewSharedCalls returns a SharedCalls.
-func NewSharedCalls() SharedCalls {
-	return &sharedGroup{
+// NewSingleFlight returns a SingleFlight.
+func NewSingleFlight() SingleFlight {
+	return &flightGroup{
 		calls: make(map[string]*call),
 	}
 }
 
-func (g *sharedGroup) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
+// NewSharedCalls returns a SingleFlight.
+// Deprecated: use NewSingleFlight.
+func NewSharedCalls() SingleFlight {
+	return NewSingleFlight()
+}
+
+func (g *flightGroup) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
 	c, done := g.createCall(key)
 	if done {
 		return c.val, c.err
@@ -43,7 +53,7 @@ func (g *sharedGroup) Do(key string, fn func() (interface{}, error)) (interface{
 	return c.val, c.err
 }
 
-func (g *sharedGroup) DoEx(key string, fn func() (interface{}, error)) (val interface{}, fresh bool, err error) {
+func (g *flightGroup) DoEx(key string, fn func() (interface{}, error)) (val interface{}, fresh bool, err error) {
 	c, done := g.createCall(key)
 	if done {
 		return c.val, false, c.err
@@ -53,7 +63,7 @@ func (g *sharedGroup) DoEx(key string, fn func() (interface{}, error)) (val inte
 	return c.val, true, c.err
 }
 
-func (g *sharedGroup) createCall(key string) (c *call, done bool) {
+func (g *flightGroup) createCall(key string) (c *call, done bool) {
 	g.lock.Lock()
 	if c, ok := g.calls[key]; ok {
 		g.lock.Unlock()
@@ -69,7 +79,7 @@ func (g *sharedGroup) createCall(key string) (c *call, done bool) {
 	return c, false
 }
 
-func (g *sharedGroup) makeCall(c *call, key string, fn func() (interface{}, error)) {
+func (g *flightGroup) makeCall(c *call, key string, fn func() (interface{}, error)) {
 	defer func() {
 		g.lock.Lock()
 		delete(g.calls, key)

core/syncx/singleflight_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func TestExclusiveCallDo(t *testing.T) {
-	g := NewSharedCalls()
+	g := NewSingleFlight()
 	v, err := g.Do("key", func() (interface{}, error) {
 		return "bar", nil
 	})
@@ -23,7 +23,7 @@ func TestExclusiveCallDo(t *testing.T) {
 }
 
 func TestExclusiveCallDoErr(t *testing.T) {
-	g := NewSharedCalls()
+	g := NewSingleFlight()
 	someErr := errors.New("some error")
 	v, err := g.Do("key", func() (interface{}, error) {
 		return nil, someErr
@@ -37,7 +37,7 @@ func TestExclusiveCallDoErr(t *testing.T) {
 }
 
 func TestExclusiveCallDoDupSuppress(t *testing.T) {
-	g := NewSharedCalls()
+	g := NewSingleFlight()
 	c := make(chan string)
 	var calls int32
 	fn := func() (interface{}, error) {
@@ -69,7 +69,7 @@ func TestExclusiveCallDoDupSuppress(t *testing.T) {
 }
 
 func TestExclusiveCallDoDiffDupSuppress(t *testing.T) {
-	g := NewSharedCalls()
+	g := NewSingleFlight()
 	broadcast := make(chan struct{})
 	var calls int32
 	tests := []string{"e", "a", "e", "a", "b", "c", "b", "a", "c", "d", "b", "c", "d"}
@@ -102,7 +102,7 @@ func TestExclusiveCallDoDiffDupSuppress(t *testing.T) {
 }
 
 func TestExclusiveCallDoExDupSuppress(t *testing.T) {
-	g := NewSharedCalls()
+	g := NewSingleFlight()
 	c := make(chan string)
 	var calls int32
 	fn := func() (interface{}, error) {