Locker v2

Breaking changes:
- The minimum Go version is go1.19
- The result parameter to (*Locker).Unlock() has been dropped. Instead
  the application will crash with the same fatal run-time error as
  calling (sync.Mutex).Unlock() on an unlocked mutex.
- ErrNoSuchLock has been removed.
- New() has been removed. The zero value is valid.

Modernize the codebase by taking advantage of Go 1.19 atomics. Add an
RWLocker for read-write locks. Add sync.Locker interface adapters for
Locker and RWLocker.

Signed-off-by: Cory Snider <csnider@mirantis.com>

Author: corhere

go.mod

@@ -1,3 +1,3 @@
-module github.com/moby/locker
+module github.com/moby/locker/v2
 
-go 1.13
+go 1.19

locker.go

@@ -14,61 +14,24 @@ waiting for the lock.
 package locker
 
 import (
-	"errors"
 	"sync"
 	"sync/atomic"
 )
 
-// ErrNoSuchLock is returned when the requested lock does not exist
-var ErrNoSuchLock = errors.New("no such lock")
-
-// Locker provides a locking mechanism based on the passed in reference name
+// Locker provides a locking mechanism based on the passed in reference name.
+// The zero value is a valid Locker.
 type Locker struct {
 	mu    sync.Mutex
 	locks map[string]*lockCtr
 }
 
 // lockCtr is used by Locker to represent a lock with a given name.
 type lockCtr struct {
-	mu sync.Mutex
-	// waiters is the number of waiters waiting to acquire the lock
-	// this is int32 instead of uint32 so we can add `-1` in `dec()`
-	waiters int32
-}
-
-// inc increments the number of waiters waiting for the lock
-func (l *lockCtr) inc() {
-	atomic.AddInt32(&l.waiters, 1)
-}
-
-// dec decrements the number of waiters waiting on the lock
-func (l *lockCtr) dec() {
-	atomic.AddInt32(&l.waiters, -1)
-}
-
-// count gets the current number of waiters
-func (l *lockCtr) count() int32 {
-	return atomic.LoadInt32(&l.waiters)
-}
-
-// Lock locks the mutex
-func (l *lockCtr) Lock() {
-	l.mu.Lock()
+	sync.Mutex
+	waiters atomic.Int32 // Number of callers waiting to acquire the lock
 }
 
-// Unlock unlocks the mutex
-func (l *lockCtr) Unlock() {
-	l.mu.Unlock()
-}
-
-// New creates a new Locker
-func New() *Locker {
-	return &Locker{
-		locks: make(map[string]*lockCtr),
-	}
-}
-
-// Lock locks a mutex with the given name. If it doesn't exist, one is created
+// Lock locks a mutex with the given name.
 func (l *Locker) Lock(name string) {
 	l.mu.Lock()
 	if l.locks == nil {
@@ -81,32 +44,49 @@ func (l *Locker) Lock(name string) {
 		l.locks[name] = nameLock
 	}
 
-	// increment the nameLock waiters while inside the main mutex
-	// this makes sure that the lock isn't deleted if `Lock` and `Unlock` are called concurrently
-	nameLock.inc()
+	// Increment the nameLock waiters while inside the main mutex.
+	// This makes sure that the lock isn't deleted if `Lock` and `Unlock` are called concurrently.
+	nameLock.waiters.Add(1)
 	l.mu.Unlock()
 
-	// Lock the nameLock outside the main mutex so we don't block other operations
-	// once locked then we can decrement the number of waiters for this lock
+	// Lock the nameLock outside the main mutex so we don't block other operations.
+	// Once locked then we can decrement the number of waiters for this lock.
 	nameLock.Lock()
-	nameLock.dec()
+	nameLock.waiters.Add(-1)
 }
 
-// Unlock unlocks the mutex with the given name
-// If the given lock is not being waited on by any other callers, it is deleted
-func (l *Locker) Unlock(name string) error {
+// Unlock unlocks the mutex with the given name.
+// It is a run-time error if the named lock is not locked on entry to Unlock.
+func (l *Locker) Unlock(name string) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
 	nameLock, exists := l.locks[name]
 	if !exists {
-		l.mu.Unlock()
-		return ErrNoSuchLock
+		// Generate an un-recover()-able error without reaching into runtime internals.
+		(&sync.Mutex{}).Unlock()
 	}
 
-	if nameLock.count() == 0 {
+	if nameLock.waiters.Load() <= 0 {
 		delete(l.locks, name)
 	}
 	nameLock.Unlock()
+}
 
-	l.mu.Unlock()
-	return nil
+type nameLocker struct {
+	l    *Locker
+	name string
+}
+
+// Locker returns a [sync.Locker] interface that implements
+// the [sync.Locker.Lock] and [sync.Locker.Unlock] methods
+// by calling l.Lock(name) and l.Unlock(name).
+func (l *Locker) Locker(name string) sync.Locker {
+	return nameLocker{l: l, name: name}
+}
+
+func (n nameLocker) Lock() {
+	n.l.Lock(n.name)
+}
+func (n nameLocker) Unlock() {
+	n.l.Unlock(n.name)
 }

locker_test.go

@@ -8,27 +8,13 @@ import (
 	"time"
 )
 
-func TestLockCounter(t *testing.T) {
-	l := &lockCtr{}
-	l.inc()
-
-	if l.waiters != 1 {
-		t.Fatal("counter inc failed")
-	}
-
-	l.dec()
-	if l.waiters != 0 {
-		t.Fatal("counter dec failed")
-	}
-}
-
 func TestLockerLock(t *testing.T) {
-	l := New()
+	var l Locker
 	l.Lock("test")
 	ctr := l.locks["test"]
 
-	if ctr.count() != 0 {
-		t.Fatalf("expected waiters to be 0, got :%d", ctr.waiters)
+	if w := ctr.waiters.Load(); w != 0 {
+		t.Fatalf("expected waiters to be 0, got %d", w)
 	}
 
 	chDone := make(chan struct{})
@@ -40,7 +26,7 @@ func TestLockerLock(t *testing.T) {
 	chWaiting := make(chan struct{})
 	go func() {
 		for range time.Tick(1 * time.Millisecond) {
-			if ctr.count() == 1 {
+			if ctr.waiters.Load() == 1 {
 				close(chWaiting)
 				break
 			}
@@ -59,23 +45,21 @@ func TestLockerLock(t *testing.T) {
 	default:
 	}
 
-	if err := l.Unlock("test"); err != nil {
-		t.Fatal(err)
-	}
+	l.Unlock("test")
 
 	select {
 	case <-chDone:
 	case <-time.After(3 * time.Second):
 		t.Fatalf("lock should have completed")
 	}
 
-	if ctr.count() != 0 {
-		t.Fatalf("expected waiters to be 0, got: %d", ctr.count())
+	if w := ctr.waiters.Load(); w != 0 {
+		t.Fatalf("expected waiters to be 0, got %d", w)
 	}
 }
 
 func TestLockerUnlock(t *testing.T) {
-	l := New()
+	var l Locker
 
 	l.Lock("test")
 	l.Unlock("test")
@@ -94,7 +78,7 @@ func TestLockerUnlock(t *testing.T) {
 }
 
 func TestLockerConcurrency(t *testing.T) {
-	l := New()
+	var l Locker
 
 	var wg sync.WaitGroup
 	for i := 0; i <= 10000; i++ {
@@ -126,15 +110,15 @@ func TestLockerConcurrency(t *testing.T) {
 }
 
 func BenchmarkLocker(b *testing.B) {
-	l := New()
+	var l Locker
 	for i := 0; i < b.N; i++ {
 		l.Lock("test")
 		l.Unlock("test")
 	}
 }
 
 func BenchmarkLockerParallel(b *testing.B) {
-	l := New()
+	var l Locker
 	b.SetParallelism(128)
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
@@ -145,7 +129,7 @@ func BenchmarkLockerParallel(b *testing.B) {
 }
 
 func BenchmarkLockerMoreKeys(b *testing.B) {
-	l := New()
+	var l Locker
 	var keys []string
 	for i := 0; i < 64; i++ {
 		keys = append(keys, strconv.Itoa(i))

rwlocker.go

@@ -0,0 +1,113 @@
+package locker
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// Locker provides a read-write lock based on the passed in reference name.
+// The zero value is a valid RWLocker.
+type RWLocker struct {
+	mu    sync.Mutex
+	locks map[string]*rwlockCtr
+}
+
+// rwlockCtr is used by RWLocker to represent a lock with a given name.
+type rwlockCtr struct {
+	sync.RWMutex
+	waiters atomic.Int32 // Number of callers waiting to acquire the lock
+}
+
+func (l *RWLocker) doLock(name string, op func(*sync.RWMutex)) {
+	l.mu.Lock()
+	if l.locks == nil {
+		l.locks = make(map[string]*rwlockCtr)
+	}
+
+	nameLock, exists := l.locks[name]
+	if !exists {
+		nameLock = &rwlockCtr{}
+		l.locks[name] = nameLock
+	}
+
+	// Increment the nameLock waiters while inside the main mutex.
+	// This makes sure that the lock isn't deleted if `doLock` and `doUnlock` are called concurrently.
+	nameLock.waiters.Add(1)
+	l.mu.Unlock()
+
+	// Lock the nameLock outside the main mutex so we don't block other operations.
+	// Once locked then we can decrement the number of waiters for this lock.
+	op(&nameLock.RWMutex)
+	nameLock.waiters.Add(-1)
+}
+
+// Lock locks the mutex with the given name for writing.
+func (l *RWLocker) Lock(name string) {
+	l.doLock(name, (*sync.RWMutex).Lock)
+}
+
+// RLock locks the mutex with the given name for reading.
+func (l *RWLocker) RLock(name string) {
+	l.doLock(name, (*sync.RWMutex).RLock)
+}
+
+func (l *RWLocker) doUnlock(name string, op func(*sync.RWMutex)) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	nameLock, exists := l.locks[name]
+	if !exists {
+		// Generate an un-recover()-able error without reaching into runtime internals.
+		op(&sync.RWMutex{})
+	}
+
+	if nameLock.waiters.Load() <= 0 {
+		delete(l.locks, name)
+	}
+	op(&nameLock.RWMutex)
+}
+
+// Unlock unlocks the mutex with the given name.
+// It is a run-time error if the named lock is not locked for writing on entry to Unlock.
+func (l *RWLocker) Unlock(name string) {
+	l.doUnlock(name, (*sync.RWMutex).Unlock)
+}
+
+// RUnlock unlocks the mutex with the given name for reading.
+// It is a run-time error if the named lock is not locked for reading on entry to RUnlock.
+func (l *RWLocker) RUnlock(name string) {
+	l.doUnlock(name, (*sync.RWMutex).RUnlock)
+}
+
+// Locker returns a [sync.Locker] interface that implements
+// the [sync.Locker.Lock] and [sync.Locker.Unlock] methods
+// by calling l.Lock(name) and l.Unlock(name).
+func (l *RWLocker) Locker(name string) sync.Locker {
+	return nameRWLocker{l: l, name: name}
+}
+
+// RLocker returns a [sync.Locker] interface that implements
+// the [sync.Locker.Lock] and [sync.Locker.Unlock] methods
+// by calling l.RLock(name) and l.RUnlock(name).
+func (l *RWLocker) RLocker(name string) sync.Locker {
+	return nameRLocker{l: l, name: name}
+}
+
+type nameRWLocker struct {
+	l    *RWLocker
+	name string
+}
+type nameRLocker nameRWLocker
+
+func (n nameRWLocker) Lock() {
+	n.l.Lock(n.name)
+}
+func (n nameRWLocker) Unlock() {
+	n.l.Unlock(n.name)
+}
+
+func (n nameRLocker) Lock() {
+	n.l.RLock(n.name)
+}
+func (n nameRLocker) Unlock() {
+	n.l.RUnlock(n.name)
+}