fix: 修复多处并发安全问题及锁实现重构

locker: 导出 RWLocker/EmptyLocker 接口, 新增 WithRWLocker, 重构
  SourceLocker 竞态、Synchronize 数据竞态

collections/linked_list: 补齐 ForEach/Size/GetAt/RemoveAt/ToList
  等方法的锁保护
collections/queue,stack: Peek/Size/IsEmpty 加锁
collections/list/linked_list: Front/Back/GetAt 加锁
maps: rwlock_map.Exist/Count, hash_map.Count 加锁
delay_queue/mem_store: Pop 原子化、Len/IsEmpty 加锁
cleanup_guard: Run() 检查 enable 标志
sets/ketama: 修复接口变更导致的 nil 空指针

locker/empty_locker.go

@@ -3,6 +3,8 @@ package locker
 var _ rwLocker = &emptyLocker{}
 var _ locker = &emptyLocker{}
 
+var EmptyLocker RWLocker = &emptyLocker{}
+
 type emptyLocker struct {
 }
 

locker/locker.go

@@ -17,6 +17,8 @@ type rwLocker interface {
 	TryRLock() bool
 }
 
+type RWLocker = rwLocker
+
 func NewLocker() *sync.Mutex {
 	return &sync.Mutex{}
 }

locker/source_locker.go

@@ -2,20 +2,16 @@ package locker
 
 import (
 	"context"
-	"fmt"
-	"sync/atomic"
 
 	redis_store "github.com/charlienet/go-mixed/locker/redis"
 	"github.com/charlienet/go-mixed/redis"
 )
 
-// 带计数器锁
 type countLocker struct {
 	rw    rwLocker
 	Count int32
 }
 
-// SourceLocker 资源锁
 type SourceLocker struct {
 	m                 RWLocker
 	distributedLocker DistributedLocker
@@ -28,7 +24,7 @@ func NewSourceLocker() *SourceLocker {
 		locks: make(map[string]*countLocker),
 	}
 
-	l.m.Synchronize()
+	l.m = NewRWLocker()
 	return l
 }
 
@@ -43,39 +39,25 @@ func (s *SourceLocker) WithDistributedLocker(distributed DistributedLocker) *Sou
 }
 
 func (s *SourceLocker) Lock(key string) {
-	s.m.RLock()
+	s.m.Lock()
 	l, ok := s.locks[key]
-	s.m.RUnlock()
-
 	if ok {
-		atomic.AddInt32(&l.Count, 1)
-		l.rw.Lock()
-
-		fmt.Println("加锁")
+		l.Count++
 	} else {
-		// 加锁，再次检查是否已经具有锁
-		s.m.Lock()
-		if l2, ok := s.locks[key]; ok {
-			s.m.Unlock()
-
-			l2.rw.Lock()
-			fmt.Println("二次检查加锁")
-		} else {
-			n := NewRWLocker()
-			s.locks[key] = &countLocker{rw: n, Count: 1}
-
-			s.m.Unlock()
-
-			n.Lock()
-		}
+		n := NewRWLocker()
+		l = &countLocker{rw: n, Count: 1}
+		s.locks[key] = l
 	}
+	s.m.Unlock()
+
+	l.rw.Lock()
 }
 
 func (s *SourceLocker) Unlock(key string) {
 	s.m.Lock()
 
 	if l, ok := s.locks[key]; ok {
-		atomic.AddInt32(&l.Count, -1)
+		l.Count--
 		l.rw.Unlock()
 
 		if s.distributedLocker != nil {
@@ -90,19 +72,25 @@ func (s *SourceLocker) Unlock(key string) {
 }
 
 func (s *SourceLocker) TryLock(key string) bool {
-	// 加读锁
-	s.m.RLock()
+	s.m.Lock()
 	l, ok := s.locks[key]
-	s.m.RUnlock()
 	if ok {
-		ret := l.rw.TryLock()
-		return ret
+		l.Count++
 	} else {
-		s.m.Lock()
 		n := NewRWLocker()
-		s.locks[key] = &countLocker{rw: n, Count: 1}
-		s.m.Unlock()
-
-		return n.TryLock()
+		l = &countLocker{rw: n, Count: 1}
+		s.locks[key] = l
 	}
+	s.m.Unlock()
+
+	if !l.rw.TryLock() {
+		s.m.Lock()
+		l.Count--
+		if l.Count == 0 {
+			delete(s.locks, key)
+		}
+		s.m.Unlock()
+		return false
+	}
+	return true
 }

locker/synchronizeable.go

@@ -24,9 +24,9 @@ func (w *Locker) WithDistributedLocker(d DistributedLocker) *Locker {
 }
 
 func (w *Locker) Synchronize() *Locker {
-	if w.mu == nil || w.mu == empty {
+	w.once.Do(func() {
 		w.mu = NewLocker()
-	}
+	})
 
 	return w
 }
@@ -59,49 +59,54 @@ type SpinLocker struct {
 }
 
 func (w *SpinLocker) Synchronize() {
-	if w.mu == nil || w.mu == empty {
+	w.once.Do(func() {
 		w.mu = NewSpinLocker()
-	}
+	})
 }
 
-type RWLocker struct {
+type WithRWLocker interface {
+	rwLocker
+	Synchronize() WithRWLocker
+}
+
+type RWLock struct {
 	once sync.Once
 	mu   rwLocker
 }
 
-func (w *RWLocker) Synchronize() *RWLocker {
-	if w.mu == nil || w.mu == empty {
+func (w *RWLock) Synchronize() WithRWLocker {
+	w.once.Do(func() {
 		w.mu = NewRWLocker()
-	}
+	})
 
 	return w
 }
 
-func (w *RWLocker) Lock() {
+func (w *RWLock) Lock() {
 	w.ensureLocker().mu.Lock()
 }
 
-func (w *RWLocker) TryLock() bool {
+func (w *RWLock) TryLock() bool {
 	return w.ensureLocker().mu.TryLock()
 }
 
-func (w *RWLocker) Unlock() {
+func (w *RWLock) Unlock() {
 	w.ensureLocker().mu.Unlock()
 }
 
-func (w *RWLocker) RLock() {
+func (w *RWLock) RLock() {
 	w.ensureLocker().mu.RLock()
 }
 
-func (w *RWLocker) TryRLock() bool {
+func (w *RWLock) TryRLock() bool {
 	return w.ensureLocker().mu.TryRLock()
 }
 
-func (w *RWLocker) RUnlock() {
+func (w *RWLock) RUnlock() {
 	w.ensureLocker().mu.RUnlock()
 }
 
-func (w *RWLocker) ensureLocker() *RWLocker {
+func (w *RWLock) ensureLocker() *RWLock {
 	w.once.Do(func() {
 		if w.mu == nil {
 			log.Println("初始化一个空锁")

locker/synchronizeable_test.go

@@ -17,7 +17,7 @@ func TestLocker(t *testing.T) {
 }
 
 func TestNew(t *testing.T) {
-	var a locker.RWLocker
+	var a locker.RWLock
 	a.Synchronize()
 
 }
@@ -30,8 +30,8 @@ func TestSpinLocker(t *testing.T) {
 	defer l.Unlock()
 }
 
-func TestRWLocker(t *testing.T) {
-	var l locker.RWLocker
+func TestRWLock(t *testing.T) {
+	var l locker.RWLock
 	l.Lock()
 }