locker

bloom/mem_store.go

@@ -2,15 +2,15 @@ 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  // 内存位图
+	set  *bitset.BitSet // 内存位图
-	lock locker.RWLocker // 同步锁
+	lock sync.RWMutex   // 同步锁
 }
 
 func newMemStore(size uint) *memStore {

locker/empty_locker.go

@@ -1,14 +1,9 @@
 package locker
 
-var _ RWLocker = &emptyLocker{}
+var _ rwLocker = &emptyLocker{}
-var _ Locker = &emptyLocker{}
+var _ locker = &emptyLocker{}
 
-var EmptyLocker = &emptyLocker{}
+type emptyLocker struct {
-
-type emptyLocker struct{}
-
-func NewEmptyLocker() *emptyLocker {
-	return &emptyLocker{}
 }
 
 func (l *emptyLocker) RLock() {}

locker/locker.go

@@ -2,14 +2,16 @@ package locker
 
 import "sync"
 
-type Locker interface {
+type locker interface {
 	Lock()
 	Unlock()
 	TryLock() bool
 }
 
-type RWLocker interface {
+type rwLocker interface {
-	Locker
+	Lock()
+	Unlock()
+	TryLock() bool
 	RLock()
 	RUnlock()
 	TryRLock() bool
@@ -18,3 +20,7 @@ type RWLocker interface {
 func NewLocker() *sync.Mutex {
 	return &sync.Mutex{}
 }
+
+func NewRWLocker() *sync.RWMutex {
+	return &sync.RWMutex{}
+}

locker/rw_locker.go

@@ -1,7 +0,0 @@
-package locker
-
-import "sync"
-
-func NewRWLocker() *sync.RWMutex {
-	return &sync.RWMutex{}
-}

locker/rw_locker_test.go

@@ -1,12 +0,0 @@
-package locker
-
-import "testing"
-
-func TestRWLokcer(t *testing.T) {
-	l := NewRWLocker()
-	l.RLock()
-
-	t.Log(l.TryRLock())
-
-	l.RUnlock()
-}

locker/synchronizeable.go

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