fix: block unlock with limit concurrency

[rfyiamcool]

change

see title 😁

[JohnRoesler]

Do you have sample code or a test that creates the issue?

[rfyiamcool]

test

when running using the latest gocron version, the following code will directly report an error. but no error will be reported when using the code in pr.

Mainly test the blocking behavior of unlock.

package main

import (
	"context"
	"fmt"
	"sync"
	"sync/atomic"
	"time"

	"github.com/go-co-op/gocron"
)

var _ gocron.Locker = (*locker)(nil)

type locker struct {
	mu    sync.Mutex
	store map[string]struct{}
}

func (l *locker) Lock(_ context.Context, key string) (gocron.Lock, error) {
	l.mu.Lock()
	defer l.mu.Unlock()
	if _, ok := l.store[key]; ok {
		return nil, gocron.ErrFailedToObtainLock
	}
	l.store[key] = struct{}{}
	return &lock{key: key, locker: l}, nil
}

var _ gocron.Lock = (*lock)(nil)

type lock struct {
	key    string
	locker *locker
}

func (l *lock) Unlock(_ context.Context) error {
	l.locker.mu.Lock()
	defer l.locker.mu.Unlock()
	delete(l.locker.store, l.key)
	return nil
}

func main() {
	var (
		queue   = make(chan int, 1)
		counter int64
		start   = time.Now()
	)

	mutex := &locker{
		store: map[string]struct{}{},
	}

	s := gocron.NewScheduler(time.UTC)
	s.WithDistributedLocker(mutex)
	s.SetMaxConcurrentJobs(1, gocron.WaitMode)

	// 1s
	s.Every(1).Seconds().Do(func() {
	})

	// 200ms
	s.Every(200).Milliseconds().Do(func() {
		atomic.AddInt64(&counter, 1)
		queue <- 1

		// fmt.Println("call 200ms")
	})

	s.StartAsync()

	var last time.Time
	for range queue {
		if last.IsZero() {
			last = time.Now()
			continue
		}

		fmt.Println(time.Since(last).String())
		if counter == 100 {
			break
		}
		if time.Since(last) > 220*time.Millisecond {
			panic("block")
		}
		last = time.Now()
	}

	fmt.Println(time.Since(start).String())
}

use lastest gocron code.

use code in pr.

[JohnRoesler]

thanks for the test 👍