fix(os/gcache): defaultcache lazy init (gogf#4468)

defaultcache更改为懒加载，在用户使用redis缓存时，避免了程序启动时不必要的初始化开销。


<img width="2638" height="806" alt="image"
src="https://github.com/user-attachments/assets/96bb0097-8463-4303-971c-ee1a9ef671a6"
/>

---------

Co-authored-by: hailaz <739476267@qq.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 3 people

contrib/registry/zookeeper/zookeeper.go

@@ -17,7 +17,7 @@ import (
 	"github.com/gogf/gf/v2/net/gsvc"
 )
 
-var _ gsvc.Registry = &Registry{}
+var _ gsvc.Registry = (*Registry)(nil)
 
 // Content for custom service Marshal/Unmarshal.
 type Content struct {

net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go

@@ -821,7 +821,7 @@ type testTracerProvider struct {
 	noop.TracerProvider
 }
 
-var _ trace.TracerProvider = &testTracerProvider{}
+var _ trace.TracerProvider = (*testTracerProvider)(nil)
 
 func (*testTracerProvider) Tracer(_ string, _ ...trace.TracerOption) trace.Tracer {
 	return noop.NewTracerProvider().Tracer("")

os/gcache/gcache.go

@@ -11,6 +11,7 @@ package gcache
 
 import (
 	"context"
+	"sync"
 	"time"
 
 	"github.com/gogf/gf/v2/container/gvar"
@@ -22,23 +23,25 @@ type Func = func(ctx context.Context) (value any, err error)
 // DurationNoExpire represents the cache key-value pair that never expires.
 const DurationNoExpire = time.Duration(0)
 
-// Default cache object.
-var defaultCache = New()
+// defaultCache returns the lazily-initialized default cache instance using sync.OnceValue.
+var defaultCache = sync.OnceValue(func() *Cache {
+	return New()
+})
 
 // Set sets cache with `key`-`value` pair, which is expired after `duration`.
 //
 // It does not expire if `duration` == 0.
 // It deletes the keys of `data` if `duration` < 0 or given `value` is nil.
 func Set(ctx context.Context, key any, value any, duration time.Duration) error {
-	return defaultCache.Set(ctx, key, value, duration)
+	return defaultCache().Set(ctx, key, value, duration)
 }
 
 // SetMap batch sets cache with key-value pairs by `data` map, which is expired after `duration`.
 //
 // It does not expire if `duration` == 0.
 // It deletes the keys of `data` if `duration` < 0 or given `value` is nil.
 func SetMap(ctx context.Context, data map[any]any, duration time.Duration) error {
-	return defaultCache.SetMap(ctx, data, duration)
+	return defaultCache().SetMap(ctx, data, duration)
 }
 
 // SetIfNotExist sets cache with `key`-`value` pair which is expired after `duration`
@@ -48,7 +51,7 @@ func SetMap(ctx context.Context, data map[any]any, duration time.Duration) error
 // It does not expire if `duration` == 0.
 // It deletes the `key` if `duration` < 0 or given `value` is nil.
 func SetIfNotExist(ctx context.Context, key any, value any, duration time.Duration) (bool, error) {
-	return defaultCache.SetIfNotExist(ctx, key, value, duration)
+	return defaultCache().SetIfNotExist(ctx, key, value, duration)
 }
 
 // SetIfNotExistFunc sets `key` with result of function `f` and returns true
@@ -60,7 +63,7 @@ func SetIfNotExist(ctx context.Context, key any, value any, duration time.Durati
 // It does not expire if `duration` == 0.
 // It deletes the `key` if `duration` < 0 or given `value` is nil.
 func SetIfNotExistFunc(ctx context.Context, key any, f Func, duration time.Duration) (bool, error) {
-	return defaultCache.SetIfNotExistFunc(ctx, key, f, duration)
+	return defaultCache().SetIfNotExistFunc(ctx, key, f, duration)
 }
 
 // SetIfNotExistFuncLock sets `key` with result of function `f` and returns true
@@ -72,14 +75,14 @@ func SetIfNotExistFunc(ctx context.Context, key any, f Func, duration time.Durat
 // Note that it differs from function `SetIfNotExistFunc` is that the function `f` is executed within
 // writing mutex lock for concurrent safety purpose.
 func SetIfNotExistFuncLock(ctx context.Context, key any, f Func, duration time.Duration) (bool, error) {
-	return defaultCache.SetIfNotExistFuncLock(ctx, key, f, duration)
+	return defaultCache().SetIfNotExistFuncLock(ctx, key, f, duration)
 }
 
 // Get retrieves and returns the associated value of given `key`.
 // It returns nil if it does not exist, or its value is nil, or it's expired.
 // If you would like to check if the `key` exists in the cache, it's better using function Contains.
 func Get(ctx context.Context, key any) (*gvar.Var, error) {
-	return defaultCache.Get(ctx, key)
+	return defaultCache().Get(ctx, key)
 }
 
 // GetOrSet retrieves and returns the value of `key`, or sets `key`-`value` pair and
@@ -90,7 +93,7 @@ func Get(ctx context.Context, key any) (*gvar.Var, error) {
 // It deletes the `key` if `duration` < 0 or given `value` is nil, but it does nothing
 // if `value` is a function and the function result is nil.
 func GetOrSet(ctx context.Context, key any, value any, duration time.Duration) (*gvar.Var, error) {
-	return defaultCache.GetOrSet(ctx, key, value, duration)
+	return defaultCache().GetOrSet(ctx, key, value, duration)
 }
 
 // GetOrSetFunc retrieves and returns the value of `key`, or sets `key` with result of
@@ -101,7 +104,7 @@ func GetOrSet(ctx context.Context, key any, value any, duration time.Duration) (
 // It deletes the `key` if `duration` < 0 or given `value` is nil, but it does nothing
 // if `value` is a function and the function result is nil.
 func GetOrSetFunc(ctx context.Context, key any, f Func, duration time.Duration) (*gvar.Var, error) {
-	return defaultCache.GetOrSetFunc(ctx, key, f, duration)
+	return defaultCache().GetOrSetFunc(ctx, key, f, duration)
 }
 
 // GetOrSetFuncLock retrieves and returns the value of `key`, or sets `key` with result of
@@ -115,12 +118,12 @@ func GetOrSetFunc(ctx context.Context, key any, f Func, duration time.Duration)
 // Note that it differs from function `GetOrSetFunc` is that the function `f` is executed within
 // writing mutex lock for concurrent safety purpose.
 func GetOrSetFuncLock(ctx context.Context, key any, f Func, duration time.Duration) (*gvar.Var, error) {
-	return defaultCache.GetOrSetFuncLock(ctx, key, f, duration)
+	return defaultCache().GetOrSetFuncLock(ctx, key, f, duration)
 }
 
 // Contains checks and returns true if `key` exists in the cache, or else returns false.
 func Contains(ctx context.Context, key any) (bool, error) {
-	return defaultCache.Contains(ctx, key)
+	return defaultCache().Contains(ctx, key)
 }
 
 // GetExpire retrieves and returns the expiration of `key` in the cache.
@@ -129,18 +132,18 @@ func Contains(ctx context.Context, key any) (bool, error) {
 // It returns 0 if the `key` does not expire.
 // It returns -1 if the `key` does not exist in the cache.
 func GetExpire(ctx context.Context, key any) (time.Duration, error) {
-	return defaultCache.GetExpire(ctx, key)
+	return defaultCache().GetExpire(ctx, key)
 }
 
 // Remove deletes one or more keys from cache, and returns its value.
 // If multiple keys are given, it returns the value of the last deleted item.
 func Remove(ctx context.Context, keys ...any) (value *gvar.Var, err error) {
-	return defaultCache.Remove(ctx, keys...)
+	return defaultCache().Remove(ctx, keys...)
 }
 
 // Removes deletes `keys` in the cache.
 func Removes(ctx context.Context, keys []any) error {
-	return defaultCache.Removes(ctx, keys)
+	return defaultCache().Removes(ctx, keys)
 }
 
 // Update updates the value of `key` without changing its expiration and returns the old value.
@@ -149,95 +152,95 @@ func Removes(ctx context.Context, keys []any) error {
 // It deletes the `key` if given `value` is nil.
 // It does nothing if `key` does not exist in the cache.
 func Update(ctx context.Context, key any, value any) (oldValue *gvar.Var, exist bool, err error) {
-	return defaultCache.Update(ctx, key, value)
+	return defaultCache().Update(ctx, key, value)
 }
 
 // UpdateExpire updates the expiration of `key` and returns the old expiration duration value.
 //
 // It returns -1 and does nothing if the `key` does not exist in the cache.
 // It deletes the `key` if `duration` < 0.
 func UpdateExpire(ctx context.Context, key any, duration time.Duration) (oldDuration time.Duration, err error) {
-	return defaultCache.UpdateExpire(ctx, key, duration)
+	return defaultCache().UpdateExpire(ctx, key, duration)
 }
 
 // Size returns the number of items in the cache.
 func Size(ctx context.Context) (int, error) {
-	return defaultCache.Size(ctx)
+	return defaultCache().Size(ctx)
 }
 
 // Data returns a copy of all key-value pairs in the cache as map type.
 // Note that this function may lead lots of memory usage, you can implement this function
 // if necessary.
 func Data(ctx context.Context) (map[any]any, error) {
-	return defaultCache.Data(ctx)
+	return defaultCache().Data(ctx)
 }
 
 // Keys returns all keys in the cache as slice.
 func Keys(ctx context.Context) ([]any, error) {
-	return defaultCache.Keys(ctx)
+	return defaultCache().Keys(ctx)
 }
 
 // KeyStrings returns all keys in the cache as string slice.
 func KeyStrings(ctx context.Context) ([]string, error) {
-	return defaultCache.KeyStrings(ctx)
+	return defaultCache().KeyStrings(ctx)
 }
 
 // Values returns all values in the cache as slice.
 func Values(ctx context.Context) ([]any, error) {
-	return defaultCache.Values(ctx)
+	return defaultCache().Values(ctx)
 }
 
 // MustGet acts like Get, but it panics if any error occurs.
 func MustGet(ctx context.Context, key any) *gvar.Var {
-	return defaultCache.MustGet(ctx, key)
+	return defaultCache().MustGet(ctx, key)
 }
 
 // MustGetOrSet acts like GetOrSet, but it panics if any error occurs.
 func MustGetOrSet(ctx context.Context, key any, value any, duration time.Duration) *gvar.Var {
-	return defaultCache.MustGetOrSet(ctx, key, value, duration)
+	return defaultCache().MustGetOrSet(ctx, key, value, duration)
 }
 
 // MustGetOrSetFunc acts like GetOrSetFunc, but it panics if any error occurs.
 func MustGetOrSetFunc(ctx context.Context, key any, f Func, duration time.Duration) *gvar.Var {
-	return defaultCache.MustGetOrSetFunc(ctx, key, f, duration)
+	return defaultCache().MustGetOrSetFunc(ctx, key, f, duration)
 }
 
 // MustGetOrSetFuncLock acts like GetOrSetFuncLock, but it panics if any error occurs.
 func MustGetOrSetFuncLock(ctx context.Context, key any, f Func, duration time.Duration) *gvar.Var {
-	return defaultCache.MustGetOrSetFuncLock(ctx, key, f, duration)
+	return defaultCache().MustGetOrSetFuncLock(ctx, key, f, duration)
 }
 
 // MustContains acts like Contains, but it panics if any error occurs.
 func MustContains(ctx context.Context, key any) bool {
-	return defaultCache.MustContains(ctx, key)
+	return defaultCache().MustContains(ctx, key)
 }
 
 // MustGetExpire acts like GetExpire, but it panics if any error occurs.
 func MustGetExpire(ctx context.Context, key any) time.Duration {
-	return defaultCache.MustGetExpire(ctx, key)
+	return defaultCache().MustGetExpire(ctx, key)
 }
 
 // MustSize acts like Size, but it panics if any error occurs.
 func MustSize(ctx context.Context) int {
-	return defaultCache.MustSize(ctx)
+	return defaultCache().MustSize(ctx)
 }
 
 // MustData acts like Data, but it panics if any error occurs.
 func MustData(ctx context.Context) map[any]any {
-	return defaultCache.MustData(ctx)
+	return defaultCache().MustData(ctx)
 }
 
 // MustKeys acts like Keys, but it panics if any error occurs.
 func MustKeys(ctx context.Context) []any {
-	return defaultCache.MustKeys(ctx)
+	return defaultCache().MustKeys(ctx)
 }
 
 // MustKeyStrings acts like KeyStrings, but it panics if any error occurs.
 func MustKeyStrings(ctx context.Context) []string {
-	return defaultCache.MustKeyStrings(ctx)
+	return defaultCache().MustKeyStrings(ctx)
 }
 
 // MustValues acts like Values, but it panics if any error occurs.
 func MustValues(ctx context.Context) []any {
-	return defaultCache.MustValues(ctx)
+	return defaultCache().MustValues(ctx)
 }

os/gcache/gcache_adapter_memory.go

@@ -29,6 +29,8 @@ type AdapterMemory struct {
 	closed      *gtype.Bool        // closed controls the cache closed or not.
 }
 
+var _ Adapter = (*AdapterMemory)(nil)
+
 // Internal event item.
 type adapterMemoryEvent struct {
 	k any   // Key.

os/gcache/gcache_adapter_redis.go

@@ -20,7 +20,9 @@ type AdapterRedis struct {
 	redis *gredis.Redis
 }
 
-// NewAdapterRedis creates and returns a new memory cache object.
+var _ Adapter = (*AdapterRedis)(nil)
+
+// NewAdapterRedis creates and returns a new Redis cache adapter.
 func NewAdapterRedis(redis *gredis.Redis) *AdapterRedis {
 	return &AdapterRedis{
 		redis: redis,

os/gcache/gcache_z_bench_test.go

@@ -10,7 +10,9 @@ package gcache_test
 
 import (
 	"context"
+	"sync"
 	"testing"
+	"time"
 
 	"github.com/gogf/gf/v2/os/gcache"
 )
@@ -79,3 +81,65 @@ func Benchmark_CacheLruRemove(b *testing.B) {
 		}
 	})
 }
+
+var oldDefaultCache = gcache.New()
+var newDefaultCache = sync.OnceValue(func() *gcache.Cache {
+	return gcache.New()
+})
+
+func BenchmarkOldImplementation(b *testing.B) {
+	ctx := context.Background()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = oldDefaultCache.Set(ctx, "key", "value", time.Minute)
+	}
+}
+
+func BenchmarkNewImplementation(b *testing.B) {
+	ctx := context.Background()
+	newDefaultCache()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = newDefaultCache().Set(ctx, "key", "value", time.Minute)
+	}
+}
+
+func BenchmarkOldGet(b *testing.B) {
+	ctx := context.Background()
+	oldDefaultCache.Set(ctx, "test_key", "test_value", time.Minute)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = oldDefaultCache.Get(ctx, "test_key")
+	}
+}
+
+func BenchmarkNewGet(b *testing.B) {
+	ctx := context.Background()
+	newDefaultCache().Set(ctx, "test_key", "test_value", time.Minute)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = newDefaultCache().Get(ctx, "test_key")
+	}
+}
+
+func BenchmarkOldConcurrent(b *testing.B) {
+	ctx := context.Background()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = oldDefaultCache.Set(ctx, "key", "value", time.Minute)
+		}
+	})
+}
+
+func BenchmarkNewConcurrent(b *testing.B) {
+	ctx := context.Background()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = newDefaultCache().Set(ctx, "key", "value", time.Minute)
+		}
+	})
+}

os/gcache/gcache_z_unit_test.go

@@ -453,22 +453,15 @@ func TestCache_SetConcurrency(t *testing.T) {
 				})
 			}
 		}()
-		select {
-		case <-time.After(2 * time.Second):
-			// t.Log("first part end")
-		}
-
+		time.Sleep(2 * time.Second)
 		go func() {
 			for {
 				pool.Add(ctx, func(ctx context.Context) {
 					cache.SetIfNotExist(ctx, 1, nil, 10)
 				})
 			}
 		}()
-		select {
-		case <-time.After(2 * time.Second):
-			// t.Log("second part end")
-		}
+		time.Sleep(2 * time.Second)
 	})
 }