分布式锁的实现

分布式锁的实现

package main

//使用 GitHub开源的分布式锁库
import (
	"context"
	"errors"
	"github.com/bsm/redislock"
	"github.com/go-redis/redis/v8"
	"log"
	"math/rand"
	"time"
	//"log"
)

var (
	//获取锁时间超时
	WaitLockTimeout = errors.New("wait for lock timeout")
)

type WatchDogLock struct {
	WaitLockTime time.Duration   // 等待锁的时间，超时自动退出
	KeyTTL       time.Duration   // key的超时时间
	LockKey      string          //lock key
	realLock     *redislock.Lock //实现的类库
	//closeSignal  context.Context //  用来判断是否关闭锁了
	client *redis.Client
	// for cancel
	cancelWatchDog func()
	//ctx            context.Context
}

func NewWatchDogLock(waitLockTime time.Duration, keyTTL time.Duration, lockKey string, cli *redis.Client) *WatchDogLock {

	return &WatchDogLock{
		WaitLockTime: waitLockTime,
		KeyTTL:       keyTTL,
		LockKey:      lockKey,
		client:       cli,
	}
}
func (w *WatchDogLock) _close() error {
	if w.client != nil {
		defer w.client.Close()
	}
	//关闭看门狗
	if w.cancelWatchDog != nil {
		//log.Println("cancel")
		w.cancelWatchDog()
	}
	//删除锁
	if w.realLock != nil {
		//log.Println("release")
		err := w.realLock.Release(context.Background())
		return err
	}

	return nil
}
func (w *WatchDogLock) TryLock() (ok bool, err error) {
	locker := redislock.New(w.client)
	var LockWaitTimeout = time.After(w.WaitLockTime)
	//设置等待锁的时间
	//ctx := context.Background()
	var lock *redislock.Lock
	//设置随机数，获取随机等待时间
	rand.Seed(time.Now().Unix())
tryLock:
	for {
		select {
		case <-LockWaitTimeout:
			log.Println("获取锁失败，已到超时时间")
			return false, WaitLockTimeout

		default:
			lock, err = locker.Obtain(context.Background(), w.LockKey, w.KeyTTL, nil)
			//无法获得锁
			if err == redislock.ErrNotObtained {
				var v = rand.Int63n(100)
				log.Println("rand v " ,v)
				time.Sleep(time.Duration(int64(time.Millisecond) * (500 + v)))
				log.Println(" try ...")

				//重试
				continue tryLock
			} else if err != nil {
				log.Println("lock unknown status %+v", err)
				return false, nil
			}
			//lock success
			break tryLock

		}

	}
	// 获得锁成功
	if lock == nil {
		log.Println("未知异常，获取锁失败 lock==nil")
		return false, errors.New("无法获得锁")
	}
	w.realLock = lock
	//自动对锁续期
	var ctx, cancel = context.WithCancel(context.Background())
	//w.ctx = ctx
	w.cancelWatchDog = cancel
	var watchDog = func() {
		for {
			select {
			case <-ctx.Done():
				log.Println("cancel watchdog")
				//被cancel掉了说明任务做完，立刻退出，不要继续加时间了
				return
			default:
				//时间不够了， 再加 4秒时间
				lock.Refresh(ctx, time.Second*30, nil)
				//刷新的话，最好睡一下
				select {
				case <-ctx.Done():
					log.Println("cancel watchdog 109")
					return
				case <-time.After(time.Second * 10):

				}
			}
		}
	}
	go watchDog()

	return true, nil
	//return
}
func (w *WatchDogLock) UnLock() error {

	return w._close()
}

package main

import (
	"github.com/go-redis/redis/v8"
	"log"
	"time"
)



//func GetEnv() {}
//

func worker(id int) {
	var client = redis.NewClient(&redis.Options{
		Network: "tcp",
		Addr:    "127.0.0.1:6379",
	})
	defer client.Close()
	locker := NewWatchDogLock(time.Second*8, time.Second*50, "mylock0", client)
	ok, err := locker.TryLock()
	if err != nil {
		if err == WaitLockTimeout {
			log.Println("等待锁超时了")
		}
		log.Println(err)
		return
	}
	if ok {
		log.Println("=== 获取锁成功 ====",id)
		time.Sleep(time.Second*2)
		err = locker.UnLock()
		log.Println("err info",err)
	}else {
		panic("获得锁失败")
	}

}

func main() {
	//3s 无法获得锁，就退出，不抢锁了
	for i := 0; i < 2; i++ {
		go worker(i)
	}

	time.Sleep(time.Second*40)

}