golang 基于 mysql 实现分布式读写锁-六虎

事务场景

由于项目刚上线，目前暂不计划引进其他中间件，所以计划经过 mysql 来完成分布式读写锁；而该事务场景也满意分布式读写锁的场景，笼统后的事务场景是：特定资源 X，能够履行 2 种操作：读操作和写操作，2种操作需要满意下面条件:

履行操作的机器分布式在不同的节点中，也便是分布式的；
读操作是同享的，也便是说同时能够有多个 goroutine 对资源 X 履行读操作；
写操作是互斥的，也便是说同一时间只允许有一个 goroutine 对资源 X 履行写操作；
读操作和写操作是互斥的，也便是说写操作和读操作不能同时存在

既然需要如此完成，下面咱们看下什么是分布式读写锁。

什么是分布式读写锁

咱们关于锁肯定不生疏，在 golang 中 sync.Mutex 锁是常见的，一般用在单节点多 goroutine 中对资源的并发拜访；可是分布式场景下，单节点 sync.Mutex 加锁的方法就会失掉效果，所以人们为了在分布式环境中完成对同享资源的互斥拜访，完成了各种分布式锁。

而分布式读写锁是比分布式锁粒度更小的锁，对事务场景的加锁会愈加灵敏，其间分布式读写锁也遵从读写锁的准则：

读形式同享，写形式互斥。
它三种形式状况: 读加锁状况、写加锁状况、无锁状况。

分布式读写锁的拜访准则与读写锁类似，下面咱们详细看下。

分布式读写锁的拜访准则

以下列表为读写锁(也便是分布式读写锁)的读写拜访准则

当时锁状况	读锁恳求	写锁恳求
无锁状况	能够	能够
读锁状况	能够	不能够
写锁状况	不能够	不能够

读锁

只要在无锁和读锁下能够获取读锁。
读锁的形式下，任何恳求读锁都能够。
读锁的形式下，恳求写锁不能够，直到所有读锁解锁，写锁才干获取到锁。

写锁

只要在无锁状况下能够获取写锁。
写锁的形式下，任何恳求读锁和写锁都阻塞，直到写锁解锁。

详细完成

假如本地没有 mysql 数据库，能够经过这篇文章快速搭建: 3min 运用 docker 搭建一个 mysql 服务。

经过 gorm 衔接 mysql

gorm 是一个 golang 的 orm 框架，能够运用它快速衔接数据库，详细代码如下:

package main
import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)
var (
	db *gorm.DB
	dbUsername = "kele"
	dbPassword = "baishi2020"
	dbHost     = "127.0.0.1:7306"
	dbDatabase = "lingmo"
	stateReadLock  = "ReadLock"
	stateWriteLock = "WriteLock"
	stateUnlock    = "Unlock"
)
type RWLock struct {
	LockMark      string `gorm:"default:'Unlock'"`
	ReadLockCount uint32 `gorm:"default:0"`
	LockReason    string
}
type Stock struct {
	gorm.Model
	RWLock
	Count int64
}
func (Stock) TableName() string {
	return "stocks"
}
func init() {
	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", dbUsername, dbPassword, dbHost, dbDatabase)
	mysqlConfig := mysql.Config{DSN: dsn}
	gormConfig := &gorm.Config{Logger: logger.Default.LogMode(logger.Info)}
	var err error
	if db, err = gorm.Open(mysql.New(mysqlConfig), gormConfig); err != nil {
		panic(err)
	}
	db.Set("db:table_options", "ENGINE = InnoDB DEFAULT CHARSET = utf8")
	// register tables
	if err = db.AutoMigrate(&Stock{}); err != nil {
		panic(err)
	}
}
func main() {
	if result := db.Model(&Stock{}).Save(&Stock{Model: gorm.Model{}, RWLock: RWLock{}, Count: 10}); result.Error != nil {
		panic(result.Error)
	}
}

首先咱们界说了一个库存表 stocks，并且在其间增加三个和读写锁相关的字段，三个字段的含义如下。

LockMark: 表明某条数据加锁的状况，只能是读锁、写锁、无锁状况中的一种。
ReadLockCount: 首先读形式是同享的，意味着能够有多个 goroutine 并发拜访，而 ReadLockCount 字段则记载当时并发拜访的 goroutine 数量。
LockReason: 记载当时加锁的原因；读锁是最新的 goroutine 的 lockReason，写锁则是写锁 goroutine 的 lockReason。

其余则是一些 gorm 衔接 mysql 逻辑，这儿不再多赘述。

完成读锁形式

详细代码如下:

func (s Stock) RLock(db *gorm.DB, lockReason string) error {
	condition := "(id = ?) AND (lock_mark != ?)"
	fields := map[string]interface{}{
		"lock_mark":       stateReadLock,
		"read_lock_count": gorm.Expr("read_lock_count + ?", 1),
		"lock_reason":     lockReason,
	}
	result := db.Model(&Stock{}).Where(condition, s.ID, stateWriteLock).Updates(fields)
	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected == 0 {
		return errors.New("failed to rlock Stock, RowsAffected=0")
	}
	return nil
}
func (s Stock) RUnlock(db *gorm.DB, UnLockReason string) error {
	sql := fmt.Sprintf(`UPDATE stocks SET read_lock_count=if(read_lock_count>0,read_lock_count-1,0), lock_mark=if(read_lock_count<1, 'Unlock', 'ReadLock'),lock_reason ='%s' where id= %d and lock_mark='%s'`, UnLockReason, s.ID, stateReadLock)
	result := db.Exec(sql)
	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected == 0 {
		return errors.New("failed to RUnlock Stock, RowsAffected=0")
	}
	return nil
}
func main() {
	if result := db.Model(&Stock{}).Save(&Stock{Model: gorm.Model{}, RWLock: RWLock{}, Count: 10}); result.Error != nil {
		panic(result.Error)
	}
	s := &Stock{Model: gorm.Model{ID: 1}}
	if result := db.Model(s).First(s); result.Error != nil {
		panic(result.Error)
	}
	if err := s.RLock(db, "readLock_reason_1"); err != nil {
		panic(err)
	}
	if err := s.RLock(db, "readLock_reason_2"); err != nil {
		panic(err)
	}
	if err := s.RUnlock(db, "readLock_unlock_1"); err != nil {
		panic(err)
	}
	if err := s.RUnlock(db, "readLock_unlock_2"); err != nil {
		panic(err)
	}
}

履行以上代码是能够正常运行的，下面咱们剖析下:

读锁的 sql 句子如下，只要在非写锁状况下就能加读锁。

UPDATE `stocks` SET `lock_mark` = 'ReadLock', `lock_reason` = 'readLock_reason_1', `read_lock_count` = read_lock_count + 1, `updated_at` = '2022-09-25 14:58:45.693' WHERE (( id = 1 )
AND ( lock_mark != 'WriteLock' )) 
AND `stocks`.`deleted_at` IS NULL

解读锁的 sql 句子如下，只要在读锁状况下才干解读锁，另外还要更新 read_lock_count 和 lock_reason 字段。

UPDATE stocks
SET read_lock_count =
IF
    ( read_lock_count > 0, read_lock_count - 1, 0 ),
    lock_mark =
IF
    ( read_lock_count < 1, 'Unlock', 'ReadLock' ),
    lock_reason = 'readLock_unlock_1' 
WHERE
    id = 1 
    AND lock_mark = 'ReadLock'

完成写锁形式

详细代码如下:


func (s Stock) WLock(db *gorm.DB, lockReason string) error {
	condition := "(id = ?) AND (lock_mark = ?)"
	fields := map[string]interface{}{
		"lock_mark":       stateWriteLock,
		"read_lock_count": 0,
		"lock_reason":     lockReason,
	}
	result := db.Model(&Stock{}).Where(condition, s.ID, stateUnlock).Updates(fields)
	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected == 0 {
		return errors.New("failed to WLock Stock, RowsAffected=0")
	}
	return nil
}
func (s Stock) WUnlock(db *gorm.DB, UnLockReason string) error {
	condition := "(id = ?) AND (lock_mark = ?)"
	fields := map[string]interface{}{
		"lock_mark":       stateUnlock,
		"read_lock_count": 0,
		"lock_reason":     UnLockReason,
	}
	result := db.Model(&Stock{}).Where(condition, s.ID, stateWriteLock).Updates(fields)
	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected == 0 {
		return errors.New("failed to WUnlock Stock, RowsAffected=0")
	}
	return nil
}
func main() {
	s := &Stock{Model: gorm.Model{ID: 1}}
	if result := db.Model(s).First(s); result.Error != nil {
		panic(result.Error)
	}
	if err := s.WLock(db, "writeLock_reason_1"); err != nil {
		panic(err)
	}
	if err := s.WUnlock(db, "unWriteLock_reason_1"); err != nil {
		panic(err)
	}
}

履行以上代码也是能够运行，下面是剖析结果

写锁的 sql 句子如下，只要在无锁状况下才干加锁成功

UPDATE `stocks` SET `lock_mark` = 'WriteLock', `lock_reason` = 'writeLock_reason_1', `read_lock_count` = 0, `updated_at` = '2022-09-25 15:06:10.71' WHERE (( id = 1 )
AND ( lock_mark = 'Unlock' )) 
AND `stocks`.`deleted_at` IS NULL

解写锁的 sql 句子如下，只要在写锁状况下才干解写锁

UPDATE `stocks` SET `lock_mark` = 'Unlock', `lock_reason` = 'unWriteLock_reason_1', `read_lock_count` = 0, `updated_at` = '2022-09-25 15:06:10.719' WHERE (( id = 1 )
AND ( lock_mark = 'WriteLock' )) 
AND `stocks`.`deleted_at` IS NULL

总结

分布式读写锁的完成有多种方法，也能够经过 etcd、redisson 的方法进行完成，而本文着重阐明可经过 mysql 来完成，这种方法的优势在于不用引进额定的组件且完成较为简单，因此也有一定的使用场景，最终感谢你的阅读。

golang 基于 mysql 实现分布式读写锁

事务场景

什么是分布式读写锁

分布式读写锁的拜访准则

读锁

写锁

详细完成

经过 gorm 衔接 mysql

完成读锁形式

完成写锁形式

总结

相关文章

Go语言实现的可读性更高的并发神库

关于 Gradle 你应该知道的知识点

工作不好找，简历该怎么写？

Go map 竟然也会发生内存泄漏？

作者信息