【Golang】redis分布式锁与本地互斥锁自由切换 (2) 切换示例

实现支持本地和Redis的互斥锁客户端

本文将分析一个支持本地缓存和Redis的互斥锁客户端的实现，介绍其设计思路和代码细节。

代码结构

代码主要包括以下几个部分：

1. MumgrInterface 和 MutexInterface 接口定义
2. MutexClient 结构体和初始化函数
3. 基于配置的互斥锁管理逻辑

接口定义

首先定义了两个接口：MumgrInterface 和 MutexInterface。

type MumgrInterface interface {
	NewMutex(name string, opts ...redsync.Option) MutexInterface
}

type MutexInterface interface {
	Lock() error
	Unlock() (bool, error)
}

MumgrInterface 接口定义了创建新互斥锁的方法 NewMutex，而 MutexInterface 接口定义了锁的基本操作 Lock 和 Unlock。

MutexClient 结构体

type MutexClient struct {
	_mutex MumgrInterface
}

MutexClient 结构体包含一个实现了 MumgrInterface 接口的字段 _mutex，用于管理具体的互斥锁实例。

初始化函数

var objc *MutexClient

func InitMutex(cfg config.View) (*MutexClient, error) {
	objc = &MutexClient{}
	expire := cfg.GetInt("mutex.expire")
	cleanup := cfg.GetInt("mutex.cleanup")
	mode := cfg.GetString("mutex.mode")
	retry := cfg.GetInt("mutex.retry")
	times := cfg.GetInt("mutex.times")
	if mode == "redis" {
		objc._mutex = initMutexRedis()
	} else {
		objc._mutex = initMutexLocal(retry, times, expire, cleanup)
	}
	return objc, nil
}

InitMutex 函数根据配置初始化 MutexClient 实例。它接受一个配置参数 cfg，读取互斥锁的相关配置参数，包括过期时间（expire）、清理时间（cleanup）、模式（mode）、重试次数（retry）和等待时间（times）。根据模式选择不同的初始化函数：本地缓存模式使用 initMutexLocal，Redis模式使用 initMutexRedis。

创建新锁

func NewMutex(name string, opts ...redsync.Option) MutexInterface {
	return objc._mutex.NewMutex(name, opts...)
}

NewMutex 函数是一个封装函数，调用当前 _mutex 实例的 NewMutex 方法创建新的互斥锁。

代码分析

1. 接口定义：通过定义接口 MumgrInterface 和 MutexInterface，使得互斥锁的实现可以灵活切换，例如可以轻松地从本地缓存切换到Redis。
2. 配置驱动：通过配置文件驱动互斥锁的初始化，使得系统可以根据不同的运行环境和需求选择合适的锁实现。
3. 封装良好：MutexClient 结构体封装了锁管理的具体实现，提供了统一的接口供外部调用，简化了使用方式。

扩展实现

为了实现完整的功能，需要实现 initMutexLocal 和 initMutexRedis 函数，以及它们各自的互斥锁管理逻辑。

本地缓存锁实现

我们在前面的代码分析中已经介绍了本地缓存锁的实现，可以复用该实现：

func initMutexLocal(retry int, times int, expire int, cleanup int) *mumgrLocal {
	if retry <= 0 {
		retry = 100
	}
	if times <= 0 {
		times = 30
	}
	_mumgrLocal = &mumgrLocal{
		retry: retry, 
		times: times, 
		caches: cache.New(
			time.Duration(expire*int(time.Second)), 
			time.Duration(cleanup*int(time.Second))
		),
	}
	return _mumgrLocal
}

Redis锁实现

假设我们有一个基于Redis的锁实现函数 initMutexRedis：

func initMutexRedis() *redisMutexManager {
	// Redis锁实现的初始化逻辑
	return &redisMutexManager{}
}

Redis锁管理逻辑

type redisMutexManager struct {
	// Redis客户端及相关配置
}

func (r *redisMutexManager) NewMutex(name string, opts ...redsync.Option) MutexInterface {
	// Redis锁的创建逻辑
	return &redisMutex{key: name}
}

type redisMutex struct {
	key string
	// 其他必要字段
}

func (r *redisMutex) Lock() error {
	// 实现Redis锁定逻辑
	return nil
}

func (r *redisMutex) Unlock() (bool, error) {
	// 实现Redis解锁逻辑
	return true, nil
}

总结

本文介绍了一种支持本地缓存和Redis的互斥锁客户端的设计与实现。通过接口和配置驱动的方式，可以灵活地选择和切换锁的实现方式。