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

完成读锁形式

完成写锁形式

总结

作者信息

推广

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

事务场景

什么是分布式读写锁

分布式读写锁的拜访准则

读锁

写锁

详细完成

经过 gorm 衔接 mysql

完成读锁形式

完成写锁形式

总结

相关文章

如果我们20年后仍然在讨论Kubernetes，那将是技术上悲哀的时刻

java 如何计算两个汉字的相似度？如何获得一个汉字的相似汉字？

GLM国产大模型训练加速：性能最高提升3倍，显存节省1/3，低成本上手

Apache Doris 在奇富科技的统一 OLAP 场景探索实践

作者信息

推广