Good way to return on locked mutex in go

Following problem:
I have a function that only should allow one caller to execute.
If someone tries to call the function and it is already busy the second caller should immediatly return with an error.

I tried the following:

1. Use a mutex

Would be pretty easy. But the problem is, you cannot check if a mutex is locked. You can only block on it. Therefore it does not work

2. Wait on a channel

var canExec = make(chan bool, 1)

func init() {
	canExec <- true
}

func onlyOne() error {
	select {
	case <-canExec:
	default:
		return errors.New("already busy")
	}

	defer func() {
		fmt.Println("done")
		canExec <- true
	}()

	// do stuff

}

What I don't like here:

• looks really messi
• if easy to mistakenly block on the channel / mistakenly write to the channel

3. Mixture of mutex and shared state

var open = true

var myMutex *sync.Mutex

func canExec() bool {
	myMutex.Lock()
	defer myMutex.Unlock()

	if open {
		open = false
		return true
	}

	return false
}

func endExec() {
	myMutex.Lock()
	defer myMutex.Unlock()

	open = true
}

func onlyOne() error {
	if !canExec() {
		return errors.New("busy")
	}
	defer endExec()

	// do stuff

	return nil
}

I don't like this either. Using a shard variable with mutex is not that nice.

Any other idea?

I'll throw my preference out there - use the atomic package.

var (
	locker    uint32
	errLocked = errors.New("Locked out buddy")
)

func OneAtATime(d time.Duration) error {
	if !atomic.CompareAndSwapUint32(&locker, 0, 1) { // <-----------------------------
		return errLocked                             //   All logic in these         |
	}                                                //   four lines                 |
	defer atomic.StoreUint32(&locker, 0)             // <-----------------------------
	
    // logic here, but we will sleep
	time.Sleep(d)

	return nil
}

The idea is pretty simple. Set the initial value to 0 (0 value of uint32). The first thing you do in the function is check if the value of locker is currently 0 and if so it changes it to 1. It does all of this atomically. If it fails simply return an error (or however else you like to handle a locked state). If successful, you immediately defer replacing the value (now 1) with 0. You don't have to use defer obviously, but failing to set the value back to 0 before returning would leave you in a state where the function could no longer be run.

After you do those 4 lines of setup, you do whatever you would normally.

https://play.golang.org/p/riryVJM4Qf

You can make things a little nicer if desired by using named values for your states.

const (
	stateUnlocked uint32 = iota
	stateLocked
)

var (
	locker    = stateUnlocked
	errLocked = errors.New("Locked out buddy")
)

func OneAtATime(d time.Duration) error {
	if !atomic.CompareAndSwapUint32(&locker, stateUnlocked, stateLocked) {
		return errLocked
	}
	defer atomic.StoreUint32(&locker, stateUnlocked)
	
    // logic here, but we will sleep
	time.Sleep(d)

	return nil
}

You can use a semaphore for this (go get golang.org/x/sync/semaphore)

package main

import (
	"errors"
	"fmt"
	"sync"
	"time"

	"golang.org/x/sync/semaphore"
)

var sem = semaphore.NewWeighted(1)

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			if err := onlyOne(); err != nil {
				fmt.Println(err)
			}
		}()
		time.Sleep(time.Second)
	}
	wg.Wait()
}

func onlyOne() error {
	if !sem.TryAcquire(1) {
		return errors.New("busy")
	}
	defer sem.Release(1)
	fmt.Println("working")
	time.Sleep(5 * time.Second)
	return nil
}

You could use standard channel approach with select statement.

var (
	ch = make(chan bool)
)

func main() {
	i := 0
	wg := sync.WaitGroup{}
	for i < 100 {
		i++
		wg.Add(1)
		go func() {
			defer wg.Done()
			err := onlyOne()
			if err != nil {
				fmt.Println("Error: ", err)
			} else {
				fmt.Println("Ok")
			}
		}()
		go func() {
			ch <- true
		}()
	}

	wg.Wait()
}


func onlyOne() error {
	select {
	case <-ch:
		// do stuff
		return nil
	default:
		return errors.New("Busy")
	}
}

Do you want a function to be executed exactly once or once at given time? In former case take a look at https://golang.org/pkg/sync/#Once.

If you want once at a time solution:

package main

import (
	"fmt"
	"sync"
	"time"
)

// OnceAtATime protects function from being executed simultaneously.
// Example:
//    func myFunc() { time.Sleep(10*time.Second) }
//    func main() {
//        once := OnceAtATime{}
//        once.Do(myFunc)
//        once.Do(myFunc) // not executed
//    }
type OnceAtATime struct {
	m        sync.Mutex
	executed bool
}

func (o *OnceAtATime) Do(f func()) {
	o.m.Lock()
	if o.executed {
		o.m.Unlock()
		return
	}
	o.executed = true
	o.m.Unlock()
	f()
	o.m.Lock()
	o.executed = false
	o.m.Unlock()
}

// Proof of concept
func f(m int, done chan<- struct{}) {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d: %d\n", m, i)
		time.Sleep(250 * time.Millisecond)
	}
	close(done)
}

func main() {
	done := make(chan struct{})
	once := OnceAtATime{}

	go once.Do(func() { f(1, done) })
	go once.Do(func() { f(2, done) })
	<-done
	done = make(chan struct{})
	go once.Do(func() { f(3, done) })
	<-done

}

https://play.golang.org/p/nZcEcWAgKp

> But the problem is, you cannot check if a mutex is locked. You can only block on it. Therefore it does not work

With possible Go 1.18 (Q1 2022), you will be able to test if a mutex is locked... without blocking on it.

See (as mentioned by Go 101) the issue 45435 from Tye McQueen :

> ## sync: add Mutex.TryLock

This is followed by CL 319769, with the caveat:

> Use of these functions is almost (but not) always a bad idea.
>
> Very rarely they are necessary, and third-party implementations (using a mutex and an atomic word, say) cannot integrate as well with the race detector as implementations in package sync itself.

The objections (since retracted) were:

> Locks are for protecting invariants.
If the lock is held by someone else, there is nothing you can say about the invariant.
>
> TryLock encourages imprecise thinking about locks; it encourages making assumptions about the invariants that may or may not be true.
That ends up being its own source of races.
>
> Thinking more about this, there is one important benefit to building TryLock into Mutex, compared to a wrapper:
failed TryLock calls wouldn't create spurious happens-before edges to confuse the race detector.

And:

> A channel-based implementation is possible, but performs poorly in comparison.
There's a reason we have sync.Mutex rather than just using channel for locking.

I came up with the following generic solution for that:

Works for me, or do you see any problem with that?

import (
 "sync"
)

const (
	ONLYONECALLER_LOCK = "onlyonecaller"
	ANOTHER_LOCK = "onlyonecaller"
)

var locks = map[string]bool{}

var mutex = &sync.Mutex{}

func Lock(lock string) bool {
	mutex.Lock()
	defer mutex.Unlock()

	locked, ok := locks[lock]
	if !ok {
		locks[lock] = true
		return true
	}

	if locked {
		return false
	}

	locks[lock] = true
	return true
}

func IsLocked(lock string) bool {
	mutex.Lock()
	defer mutex.Unlock()

	locked, ok := locks[lock]
	if !ok {
		return false
	}

	return locked
}

func Unlock(lock string) {
	mutex.Lock()
	defer mutex.Unlock()

	locked, ok := locks[lock]
	if !ok {
		return
	}

	if !locked {
		return
	}

	locks[lock] = false
}

see: https://play.golang.org/p/vUUsHcT3L-

How about this package: https://github.com/viney-shih/go-lock . It use channel and semaphore (golang.org/x/sync/semaphore) to solve your problem.

go-lock implements TryLock, TryLockWithTimeout and TryLockWithContext functions in addition to Lock and Unlock. It provides flexibility to control the resources.

Examples:

package main

import (
    "fmt"
    "time"
    "context"

    lock "github.com/viney-shih/go-lock"
)

func main() {
    casMut := lock.NewCASMutex()

    casMut.Lock()
    defer casMut.Unlock()

    // TryLock without blocking
    fmt.Println("Return", casMut.TryLock()) // Return false

    // TryLockWithTimeout without blocking
    fmt.Println("Return", casMut.TryLockWithTimeout(50*time.Millisecond)) // Return false

    // TryLockWithContext without blocking
    ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
    defer cancel()

    fmt.Println("Return", casMut.TryLockWithContext(ctx)) // Return false
    

    // Output:
    // Return false
    // Return false
    // Return false
}

Lets keep it simple:

    package main
    
    import (
     "fmt"
     "time"
     "golang.org/x/sync/semaphore"
    )

    var sem *semaphore.NewWeighted(1)

    func init() {
      sem = emaphore.NewWeighted(1)
    }

    func doSomething() {
      if !sem.TryAcquire(1) {
        return errors.New("I'm busy")
      }
      defer sem.Release(1)
      fmt.Println("I'm doing my work right now, then I'll take a nap")
      time.Sleep(10)
    }

    func main() {
      go func() {
        doSomething()
      }()
    }