lock

README

mysql-lock

a simple distributed lock based on mysql

• 中文 README

Usage

go get github.com/vearne/mysql-lock

mysql-lock uses 2 methods to build MySQL's distributed lock

• Method 1: row lock initialization

mlock.NewRowLockWithDSN()
mlock.NewRowLockWithConn()

• Method 2: set flag initialization

mlock.NewCounterLockWithDSN()
mlock.NewCounterLockWithConn()

Notice :Distributed locks based on mysql are not rigorous for method 1.

For example, at t1, A holds the lock, and B waits for the lock. At t2, the network between A and MySQL is abnormal. MySQL actively releases the lock imposed by A (rolling back the transaction that A has not committed), and B adds the lock. At this time, A will think that it owns the lock; B will also think that it holds the lock. The distributed lock actually fails.

Notice: mysql-lock will create the table.

• Method 1 creates the table _lock_store.
• Method 2 creates the table _lock_counter.

So mysql-lock needs CREATE permission. Or you can use doc/schema.sql to create the table yourself.

Example

import (
	mlock "github.com/vearne/mysql-lock"
	"log"
	"time"
)

func main() {
	//debug := false
	debug := true
	dsn := "tc_user:20C462C9C614@tcp(127.0.0.1:3306)/xxx?charset=utf8&loc=Asia%2FShanghai&parseTime=true"

	var locker *mlock.MySQCounterLock
	locker = mlock.NewCounterLockWithDSN(dsn, debug)

	// init() can be executed multiple times
	locker.Init([]string{"lock1", "lock2"})
	// optional, only for CounterLock
	//locker.SetClientID("client1")
	// optional, only for CounterLock
	// default 1 minutes
	locker.SetMaxLockTime(1 * time.Minute)
	// optional, only for CounterLock
	// default NewLinearBackOff(1*time.Second)
	locker.WithBackOff(mlock.NewLinearBackOff(2 * time.Second))

	beginTime := time.Now()
	// max wait for 5 secs
	err := locker.Acquire("lock1", 50*time.Second)
	if err != nil {
		log.Println("can't acquire lock", "error", err)
		log.Println(time.Since(beginTime))
		return
	}

	log.Println("got lock1")
	log.Println(time.Since(beginTime))
	time.Sleep(30 * time.Second)
	locker.Release("lock1")
	log.Println("release lock1")
}

Documentation

Index

• Constants
• func InitMySQLWithConn(sqlDB *sql.DB, debug bool) *gorm.DB
• func InitMySQLWithDSN(dsn string, debug bool) *gorm.DB
• type BackOff
• type ConstantBackOff
  • func NewConstantBackOff(d time.Duration) *ConstantBackOff
  • func (b *ConstantBackOff) NextBackOff() time.Duration
  • func (b *ConstantBackOff) Reset()
• type DoneStore
  • func NewDoneStore() *DoneStore
  • func (d *DoneStore) CLoseDoneChan(lockName string)
  • func (d *DoneStore) CreateDoneChan(lockName string)
  • func (d *DoneStore) GetDoneChan(lockName string) chan struct{}
• type ExponentialBackOff
  • func NewExponentialBackOff(initInterval time.Duration, multiplier float64) *ExponentialBackOff
  • func (l *ExponentialBackOff) NextBackOff() time.Duration
  • func (l *ExponentialBackOff) Reset()
• type LinearBackOff
  • func NewLinearBackOff(initInterval time.Duration) *LinearBackOff
  • func (l *LinearBackOff) NextBackOff() time.Duration
  • func (l *LinearBackOff) Reset()
• type LockCounter
  • func (LockCounter) TableName() string
• type LockStore
  • func (LockStore) TableName() string
• type MySQCounterLock
  • func NewCounterLockWithConn(db *sql.DB, debug bool) *MySQCounterLock
  • func NewCounterLockWithDSN(dsn string, debug bool) *MySQCounterLock
  • func (l *MySQCounterLock) Acquire(lockName string, wait time.Duration) error
  • func (l *MySQCounterLock) Init(lockNameList []string)
  • func (l *MySQCounterLock) Refresh(lockName string) error
  • func (l *MySQCounterLock) Release(lockName string) error
  • func (l *MySQCounterLock) SetClientID(clientID string)
  • func (l *MySQCounterLock) SetMaxLockTime(d time.Duration)
  • func (l *MySQCounterLock) StopRefresh(lockName string)
  • func (l *MySQCounterLock) WithBackOff(b BackOff)
• type MySQLLockItf
• type MySQRowLock
  • func NewRowLockWithConn(db *sql.DB, debug bool) *MySQRowLock
  • func NewRowLockWithDSN(dsn string, debug bool) *MySQRowLock
  • func (l *MySQRowLock) Acquire(lockName string, wait time.Duration) error
  • func (l *MySQRowLock) Init(lockNameList []string)
  • func (l *MySQRowLock) Release(lockName string) error

Constants

const (
	LockStatusOpen   = 0
	LockStatusClosed = 1
)

Functions

func InitMySQLWithConn

func InitMySQLWithConn(sqlDB *sql.DB, debug bool) *gorm.DB

initialize *gorm.DB with an existing database connection

func InitMySQLWithDSN

func InitMySQLWithDSN(dsn string, debug bool) *gorm.DB

initialize *gorm.DB with dsn

Types

type BackOff

type BackOff interface {
	NextBackOff() time.Duration

	// Reset to initial state.
	Reset()
}

BackOff is a backoff policy for retrying an operation.

type ConstantBackOff

type ConstantBackOff struct {
	Interval time.Duration
}

func NewConstantBackOff

func NewConstantBackOff(d time.Duration) *ConstantBackOff

func (*ConstantBackOff) NextBackOff

func (b *ConstantBackOff) NextBackOff() time.Duration

func (*ConstantBackOff) Reset

func (b *ConstantBackOff) Reset()

type DoneStore

type DoneStore struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewDoneStore

func NewDoneStore() *DoneStore

func (*DoneStore) CLoseDoneChan

func (d *DoneStore) CLoseDoneChan(lockName string)

func (*DoneStore) CreateDoneChan

func (d *DoneStore) CreateDoneChan(lockName string)

func (*DoneStore) GetDoneChan

func (d *DoneStore) GetDoneChan(lockName string) chan struct{}

type ExponentialBackOff

type ExponentialBackOff struct {
	InitialInterval time.Duration
	Multiplier      float64
	Counter         int
}

func NewExponentialBackOff

func NewExponentialBackOff(initInterval time.Duration, multiplier float64) *ExponentialBackOff

func (*ExponentialBackOff) NextBackOff

func (l *ExponentialBackOff) NextBackOff() time.Duration

func (*ExponentialBackOff) Reset

func (l *ExponentialBackOff) Reset()

type LinearBackOff

type LinearBackOff struct {
	InitialInterval time.Duration
	Counter         int
}

func NewLinearBackOff

func NewLinearBackOff(initInterval time.Duration) *LinearBackOff

func (*LinearBackOff) NextBackOff

func (l *LinearBackOff) NextBackOff() time.Duration

func (*LinearBackOff) Reset

func (l *LinearBackOff) Reset()

type LockCounter

type LockCounter struct {
	Name       string    `gorm:"column:name;size:100;index:uni_name,unique" json:"name"`
	Owner      string    `gorm:"column:owner;size:100" json:"owner"`
	Counter    uint64    `gorm:"column:counter" json:"counter"`
	CreatedAt  time.Time `gorm:"column:created_at" json:"createdAt"`
	ModifiedAt time.Time `gorm:"column:modified_at" json:"modifiedAt"`
	ExpiredAt  time.Time `gorm:"column:expired_at" json:"expiredAt"`
	// other
	ID int `gorm:"column:id" json:"id"`
}

func (LockCounter) TableName

func (LockCounter) TableName() string

type LockStore

type LockStore struct {
	Name      string    `gorm:"column:name;size:100;index:uni_name,unique" json:"name"`
	CreatedAt time.Time `gorm:"column:created_at" json:"createdAt"`
	// other
	ID int `gorm:"column:id" json:"id"`
}

func (LockStore) TableName

func (LockStore) TableName() string

type MySQCounterLock

type MySQCounterLock struct {
	MySQLClient *gorm.DB
	ClientID    string
	MaxLockTime time.Duration
	// contains filtered or unexported fields
}

func NewCounterLockWithConn

func NewCounterLockWithConn(db *sql.DB, debug bool) *MySQCounterLock

func NewCounterLockWithDSN

func NewCounterLockWithDSN(dsn string, debug bool) *MySQCounterLock

func (*MySQCounterLock) Acquire

func (l *MySQCounterLock) Acquire(lockName string, wait time.Duration) error

Lock :If the lock cannot be obtained, it will keep blocking wait: < 0 no wait

func (*MySQCounterLock) Init

func (l *MySQCounterLock) Init(lockNameList []string)

Init :Create tables

func (*MySQCounterLock) Refresh

func (l *MySQCounterLock) Refresh(lockName string) error

func (*MySQCounterLock) Release

func (l *MySQCounterLock) Release(lockName string) error

func (*MySQCounterLock) SetClientID

func (l *MySQCounterLock) SetClientID(clientID string)

func (*MySQCounterLock) SetMaxLockTime

func (l *MySQCounterLock) SetMaxLockTime(d time.Duration)

func (*MySQCounterLock) StopRefresh

func (l *MySQCounterLock) StopRefresh(lockName string)

func (*MySQCounterLock) WithBackOff

func (l *MySQCounterLock) WithBackOff(b BackOff)

type MySQLLockItf

type MySQLLockItf interface {
	Init(lockNameList []string)
	Acquire(lockName string, wait time.Duration) error
	Release(lockName string) error
}

type MySQRowLock

type MySQRowLock struct {
	sync.Mutex
	MySQLClient *gorm.DB
	TXMap       map[string]*gorm.DB
}

func NewRowLockWithConn

func NewRowLockWithConn(db *sql.DB, debug bool) *MySQRowLock

func NewRowLockWithDSN

func NewRowLockWithDSN(dsn string, debug bool) *MySQRowLock

func (*MySQRowLock) Acquire

func (l *MySQRowLock) Acquire(lockName string, wait time.Duration) error

Lock :If the lock cannot be obtained, it will keep blocking

func (*MySQRowLock) Init

func (l *MySQRowLock) Init(lockNameList []string)

Init :Create tables Create row record

func (*MySQRowLock) Release

func (l *MySQRowLock) Release(lockName string) error