use base locker

bloom/bloom.go

@@ -5,7 +5,6 @@ import (
 	"math"
 
 	"github.com/charlienet/go-mixed/bytesconv"
-	"github.com/charlienet/go-mixed/expr"
 	"github.com/charlienet/go-mixed/hash"
 	"github.com/charlienet/go-mixed/redis"
 )
@@ -58,10 +57,7 @@ func New(expectedInsertions uint, fpp float64, opts ...option) *BloomFilter {
 	bf := &BloomFilter{
 		bits:  bits,
 		funcs: k,
-		store: expr.Ternary[bitStore](
-			opt.redisClient == nil,
-			newMemStore(bits),
-			newRedisStore(opt.redisClient, opt.redisKey, bits)),
+		store: createBitStore(opt, bits),
 	}
 
 	return bf
@@ -104,6 +100,14 @@ func (bf *BloomFilter) Clear() {
 	bf.store.Clear()
 }
 
+func createBitStore(opt *bloomOptions, bits uint) bitStore {
+	if opt.redisClient != nil {
+		return newRedisStore(opt.redisClient, opt.redisKey, bits)
+	}
+
+	return newMemStore(bits)
+}
+
 // 计算优化的位图长度，
 // n 期望放置元素数量，
 // p 预期的误判概率

bloom/mem_store.go

@@ -2,22 +2,21 @@ package bloom
 
 import (
 	"context"
+	"sync"
 
 	"github.com/bits-and-blooms/bitset"
-	"github.com/charlienet/go-mixed/locker"
 )
 
 type memStore struct {
 	size uint
-	set  *bitset.BitSet  // 内存位图
-	lock locker.RWLocker // 同步锁
+	set  *bitset.BitSet // 内存位图
+	lock sync.RWMutex   // 同步锁
 }
 
 func newMemStore(size uint) *memStore {
 	return &memStore{
 		size: size,
 		set:  bitset.New(size),
-		lock: locker.NewRWLocker(),
 	}
 }
 

configure/configure.go

@@ -5,11 +5,13 @@ import (
 	"github.com/spf13/viper"
 )
 
-type Configure interface {
-	GetString(string, string) string
-}
+type NotifyFunc func(Configure) error
 
-type NotifyFunc func(Configure)
+type Configure interface {
+	Load(dataId string, v any, onChanged ...NotifyFunc) error
+	GetString(string, string) string
+	GetInt(key string, defaultValue int) int
+}
 
 type conf struct {
 	viper            *viper.Viper            //

locker/synchronizeable.go

@@ -3,94 +3,111 @@ package locker
 import (
 	"log"
 	"sync"
+
+	"github.com/charlienet/go-mixed/redis"
 )
 
-type WithLocker struct {
-	once sync.Once
-	mu   Locker
+var empty = &emptyLocker{}
+
+type Locker struct {
+	once              sync.Once
+	distributedLocker DistributedLocker // 分布式锁
+	mu                locker
 }
 
-func (w *WithLocker) Synchronize() {
-	if w.mu == nil || w.mu == EmptyLocker {
+func (w *Locker) WithRedis(key string, rdb redis.Client) *Locker {
+	return w
+}
+
+func (w *Locker) WithDistributedLocker(d DistributedLocker) *Locker {
+	return w
+}
+
+func (w *Locker) Synchronize() *Locker {
+	if w.mu == nil || w.mu == empty {
 		w.mu = NewLocker()
 	}
+
+	return w
 }
 
-func (w *WithLocker) Lock() {
-	w.ensureLocker().Lock()
+func (w *Locker) Lock() {
+	w.ensureLocker().mu.Lock()
 }
 
-func (w *WithLocker) Unlock() {
-	w.ensureLocker().Unlock()
+func (w *Locker) Unlock() {
+	w.ensureLocker().mu.Unlock()
 }
 
-func (w *WithLocker) TryLock() bool {
-	return w.ensureLocker().TryLock()
+func (w *Locker) TryLock() bool {
+	return w.ensureLocker().mu.TryLock()
 }
 
-func (w *WithLocker) ensureLocker() Locker {
+func (w *Locker) ensureLocker() *Locker {
 	w.once.Do(func() {
 		if w.mu == nil {
-			w.mu = EmptyLocker
+			w.mu = empty
 		}
+
 	})
 
-	return w.mu
+	return w
 }
 
-type WithSpinLocker struct {
-	WithLocker
+type SpinLocker struct {
+	Locker
 }
 
-func (w *WithSpinLocker) Synchronize() {
-	if w.mu == nil || w.mu == EmptyLocker {
+func (w *SpinLocker) Synchronize() {
+	if w.mu == nil || w.mu == empty {
 		w.mu = NewSpinLocker()
 	}
 }
 
-type WithRWLocker struct {
+type RWLocker struct {
 	once sync.Once
-	mu   RWLocker
+	mu   rwLocker
 }
 
-func (w *WithRWLocker) Synchronize() {
-	if w.mu == nil || w.mu == EmptyLocker {
-		log.Println("初始化有效锁")
+func (w *RWLocker) Synchronize() *RWLocker {
+	if w.mu == nil || w.mu == empty {
 		w.mu = NewRWLocker()
 	}
+
+	return w
 }
 
-func (w *WithRWLocker) Lock() {
-	w.ensureLocker().Lock()
+func (w *RWLocker) Lock() {
+	w.ensureLocker().mu.Lock()
 }
 
-func (w *WithRWLocker) TryLock() bool {
-	return w.ensureLocker().TryLock()
+func (w *RWLocker) TryLock() bool {
+	return w.ensureLocker().mu.TryLock()
 }
 
-func (w *WithRWLocker) Unlock() {
-	w.ensureLocker().Unlock()
+func (w *RWLocker) Unlock() {
+	w.ensureLocker().mu.Unlock()
 }
 
-func (w *WithRWLocker) RLock() {
-	w.ensureLocker().RLock()
+func (w *RWLocker) RLock() {
+	w.ensureLocker().mu.RLock()
 }
 
-func (w *WithRWLocker) TryRLock() bool {
-	return w.ensureLocker().TryRLock()
+func (w *RWLocker) TryRLock() bool {
+	return w.ensureLocker().mu.TryRLock()
 }
 
-func (w *WithRWLocker) RUnlock() {
-	w.ensureLocker().RUnlock()
+func (w *RWLocker) RUnlock() {
+	w.ensureLocker().mu.RUnlock()
 }
 
-func (w *WithRWLocker) ensureLocker() RWLocker {
+func (w *RWLocker) ensureLocker() *RWLocker {
 	w.once.Do(func() {
 		if w.mu == nil {
 			log.Println("初始化一个空锁")
-			w.mu = EmptyLocker
+			w.mu = empty
 		}
 	})
 
-	return w.mu
+	return w
 }