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.

• 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.

• Method 2: For example, at time t1, A holds the lock and B waits for the lock. At time t2, A suddenly crashes, causing the lock to not be released normally. then B will never be able to acquire the lock.

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

package main

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

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

	var locker mlock.MySQLLockItf
	locker = mlock.NewRowLockWithDSN(dsn, debug)
	//locker = mlock.NewCounterLockWithDSN(dsn, debug)

	// init() can be executed multiple times
	locker.Init([]string{"lock1", "lock2"})

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

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

Documentation

Index

• Constants
• func InitMySQLWithConn(sqlDB *sql.DB) *gorm.DB
• func InitMySQLWithDSN(dsn string, debug bool) *gorm.DB
• type LockCounter
  • func (LockCounter) TableName() string
• type LockStore
  • func (LockStore) TableName() string
• type MySQCounterLock
  • func (l *MySQCounterLock) Acquire(lockName string, wait time.Duration) error
  • func (l *MySQCounterLock) Init(lockNameList []string)
  • func (l *MySQCounterLock) Release(lockName string) error
• type MySQLLockItf
  • func NewCounterLockWithConn(db *sql.DB) MySQLLockItf
  • func NewCounterLockWithDSN(dsn string, debug bool) MySQLLockItf
  • func NewRowLockWithConn(db *sql.DB) MySQLLockItf
  • func NewRowLockWithDSN(dsn string, debug bool) MySQLLockItf
• type MySQRowLLock
  • func (l *MySQRowLLock) Acquire(lockName string, wait time.Duration) error
  • func (l *MySQRowLLock) Init(lockNameList []string)
  • func (l *MySQRowLLock) Release(lockName string) error

Constants

const (
	LockStatusOpen   = 0
	LockStatusClosed = 1
)

Functions

func InitMySQLWithConn

func InitMySQLWithConn(sqlDB *sql.DB) *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 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"`
	// 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
}

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) Release

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

type MySQLLockItf

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

func NewCounterLockWithConn

func NewCounterLockWithConn(db *sql.DB) MySQLLockItf

func NewCounterLockWithDSN

func NewCounterLockWithDSN(dsn string, debug bool) MySQLLockItf

func NewRowLockWithConn

func NewRowLockWithConn(db *sql.DB) MySQLLockItf

func NewRowLockWithDSN

func NewRowLockWithDSN(dsn string, debug bool) MySQLLockItf

type MySQRowLLock

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

func (*MySQRowLLock) Acquire

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

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

func (*MySQRowLLock) Init

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

Init :Create tables Create row record

func (*MySQRowLLock) Release

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