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
}

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
}

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
}

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
}

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
}

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")
	}
}

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
}

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
}

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
}

    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()
      }()
    }