Golang使用redis实现分布式锁(redigo框架)

最新推荐文章于 2024-05-29 09:40:55 发布
最新推荐文章于 2024-05-29 09:40:55 发布
阅读量945 收藏 17
点赞数 21
文章标签： golang redis 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HideonHacker/article/details/137639818
版权

本文思路来自Wx公众号：小徐生先生的变成世界，原文地址

分布式锁

个人理解分布式锁是分布式服务器的单机锁，对于单机锁是保证服务器在同一时间只能有一个线程能访问该方法。但是对于分布式服务器来说，可能存在多台服务器接收用户请求，这样请求在不同服务器的数据就没办法通过单机锁来阻塞。所以才需要通过额外的组件，实现多服务器之间的管理。

选型Redis的原因

  1. Redis高效且具备高可用性，当提供分布式锁服务的基础组件中存在少量节点发生故障时，不应该影响到分布式锁服务的稳定性。
  2. Redis是kv的形式存储信息，可以保证存储锁的同时，存储对应的用户信息。
  3. 健壮性：对于数据Redis可以设置过期时间，杜绝了死锁的产生，在很久没有操作的时候会自动释放锁。
  4. 独占性，因为key是存在唯一性的，所以不会存在同一时间有两个锁的情况。
  5. SETNX语句，Redis存在SETNX，支持创建前先查询是否存在相同的key，操作更加方便。
  6. 存在mysql相似的事务功能Eval，可以将多个数据合并操作，保证了解锁时的原子性。

实现思路

  • 针对于同一把分布式锁，使用同一条数据进行标识（以 redis 为例，则为同一个 key 对应的 kv 数据记录）
  • 假如在存储介质成功插入了该条数据（要求之前该 key 对应的数据不存在），则被认定为加锁成功
  • 把从存储介质中删除该条数据这一行为理解为释放锁操作
  • 倘若在插入该条数据时，发现数据已经存在（锁已被他人持有），则持续轮询，直到数据被他人删除（他人释放锁），并由自身完成数据插入动作为止（取锁成功）
  • 由于是并发场景，需要保证
    • 检查数据是否已被插入
    • 数据不存在则插入数据 】这两个步骤之间是原子化不可拆分的（在 redis 中是 set only if not exist —— SETNX 操作）

弱一致性问题

回顾 redis 的设计思路，为避免单点故障问题，redis 会基于主从复制的方式实现数据备份. （以哨兵机制为例，哨兵会持续监听 master 节点的健康状况，倘若 master 节点发生故障，哨兵会负责扶持 slave 节点上位，以保证整个集群能够正常对外提供服务）. 此外，在 CAP 体系中，redis 走的是 AP 路线，为保证服务的吞吐性能，主从节点之间的数据同步是异步延迟进行的.
到这里问题就来了，试想一种场景：倘若 使用方 A 在 redis master 节点加锁成功，但是对应的 kv 记录在同步到 slave 之前，master 节点就宕机了. 此时未同步到这项数据的 slave 节点升为 master，这样分布式锁被 A 持有的“凭证” 就这样凭空消失了. 于是不知情的使用方 B C D 都可能加锁成功，于是就出现了一把锁被多方同时持有的问题，导致分布式锁最基本的独占性遭到破坏.
关于这个问题，一个比较经典的解决方案是：redis 红锁（redlock，全称 redis distribution lock）

sdk介绍跟项目开源地址

  • 首先，本文使用到基于 golang 编写的 redis 客户端 sdk：redigo，用于和 redis 组件进行交互redigo 开源地址
  • 小徐老师的分布式程序开源地址，其中还提供了引用sdk，如果不想了解项目代码的，可以直接go mod 引用sdk就可以使用啦

源码部分，其中包含自己的一些见解

封装Client客户端，以下介绍一下方法的具体作用

  1. Client类
    1. 继承配置文件ClientOptions
      1. MaxIdel 最大空闲连接
      2. idelTimeoutSeconds 超时时间
      3. max Active 最大活跃连接
    2. pool redis连接池
  2. NewClient 创建客户端方法
  3. getRedisPool 获取Redis连接池
  4. getRedisConn 生成redis操作实例，会存到pool中
  5. getConn 根据上下文context到pool中获取操作实例
  6. setNEX 封装过期时间，key判断跟添加操作到一起
  7. Eval 支持事务形式的操作，为了后续解锁做准备
package redisLock

import (
	"context"
	"errors"
	"fmt"
	"github.com/gomodule/redigo/redis"
	"time"
)

type Client struct {
	// 继承 ClientOptions
	ClientOptions
	// pool 连接池，用来存储redis连接的
	pool *redis.Pool
}

func (this *Client) Println() {
	fmt.Println(this.network, this.address, this.maxIdle)
}

func NewClient(network string, address string, password string, opts ...ClientOption) *Client {

	fmt.Println(2)
	// 创建Client，分配基础配置
	c := Client{
		ClientOptions: ClientOptions{
			network:  network,
			address:  address,
			password: password,
		},
	}

	// 传参为函数的时候，就已经执行了函数方法了
	// 执行顺序是 传参时执行 函数的方法体 --> 执行完执行接收传参的方法 --> 执行到传第二次参才进行第二次return --> 执行return方法体
	// opt = WithMaxIdle(4).return
	for _, opt := range opts {
		fmt.Println(3)
		// opt() == func(c *ClientOptions)
		// opt 即 return方法
		// 如果此刻不传参，则不执行return方法
		opt(&c.ClientOptions)
	}

	// 默认初始化
	repairClient(&c.ClientOptions)

	// 创建线程池
	pool := c.getRedisPool()

	fmt.Println("创建客户端成功...")

	// 线程池分配给新的client
	return &Client{
		pool: pool,
	}

}

// getRedisPool 创建RedisPool连接池
func (this *Client) getRedisPool() *redis.Pool {
	return &redis.Pool{
		// 最大空闲
		MaxIdle: this.maxIdle,
		// 最大连接
		MaxActive: this.maxActive,
		// 超时时间
		IdleTimeout: time.Duration(this.idleTimeoutSeconds) * time.Second,
		// 客户端存储的地方? redis.Conn
		Dial: func() (redis.Conn, error) {
			c, err := this.getRedisConn()
			if err != nil {
				return nil, err
			}
			return c, nil
		},
		// 等待阻塞
		Wait: this.wait,
		// 测试连接方式?
		TestOnBorrow: func(c redis.Conn, t time.Time) error {
			_, err := c.Do("PING")
			return err
		},
	}
}

// getRedisConn 生成RedisConn连接
func (c *Client) getRedisConn() (redis.Conn, error) {
	// 判断address是否为空
	if c.address == "" {
		panic("Cannot get redis address from config")
	}
	// 连接配置文件?
	var dialOpts []redis.DialOption
	if len(c.password) > 0 {
		// 密码不为空，则设置密码进入配置文件
		dialOpts = append(dialOpts, redis.DialPassword(c.password))
	}
	// 使用background生成上下文
	conn, err := redis.DialContext(context.Background(),
		c.network, c.address, dialOpts...)
	if err != nil {
		return nil, err
	}
	return conn, nil
}

// GetConn 从连接池获取conn
func (c *Client) GetConn(ctx context.Context) (redis.Conn, error) {
	// 连接池自带方法 GetContext,传入context
	return c.pool.GetContext(ctx)
}

// SetNEX 加锁操作，包含过期时间等参数设置
func (c *Client) SetNEX(ctx context.Context, key, value string, expireSeconds int64) (string, error) {

	// 判断键值是否为空，空的话不需要获取conn，减少空间消耗
	if key == "" || value == "" {
		return "", errors.New("key or value is null!")
	}
	// 根据上下文获取conn
	conn, err := c.GetConn(ctx)
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// 拼接redis语句，并发送给redis
	reply, err := conn.Do("SET", key, value, "EX", expireSeconds, "NX")
	// 判断接收数据，是否报错
	if err != nil {
		return "", err
	}
	if reply == nil {
		return "", nil
	}
	// 将接收的更改行转化为int64的状态
	return reply.(string), nil
}

// Eval 支持redis的事务操作，为了解锁操作统一而确定的
func (c *Client) Eval(ctx context.Context, src string, keyCount int, keysAndArgs []interface{}) (interface{}, error) {
	// ctx 上下文参数，用来获取conn
	args := make([]interface{}, 2+len(keysAndArgs))
	args[0] = src
	// 这是干嘛的????key有几个的标志?
	args[1] = keyCount
	copy(args[2:], keysAndArgs)

	conn, err := c.pool.GetContext(ctx)
	if err != nil {
		return -1, err
	}
	defer conn.Close()
	return conn.Do("EVAL", args...)
}

Options 配置文件（客户端 + 锁）

  1. ClientOptions 客户端配置类，具体内容在上面介绍过了
    2. wait 阻塞判断值
    3. network 网络连接方式
    4. address 连接地址
    5. password redis密码
  2. ClientOption 高阶函数返回值，用方法来作为返回值，很有趣的设计
  3. WithMaxIdel 设置参数
  4. WithIdelTimeoutSeconds 设置参数
  5. WithMaxActive 设置参数
  6. WithWaitMode 设置参数
  7. repairClient 默认设置
  8. LockOptions 锁的配置类
    1. isBlock 阻塞判断
    2. blockWaitingSeconds 阻塞等待时间
    3. expireSeconds 锁过期时间
  9. WithBlock 设置参数
  10. WithBlockWaitingSeconds 设置参数
  11. WithExpireSeconds 设置参数
package redisLock

import "fmt"

const (
	// DefaultIdleTimeoutSeconds 默认连接池超过 10 s 释放连接
	DefaultIdleTimeoutSeconds = 10
	// DefaultMaxActive 默认最大激活连接数
	DefaultMaxActive = 100
	// DefaultMaxIdle 默认最大空闲连接数
	DefaultMaxIdle = 20
)

type ClientOptions struct {
	maxIdle            int
	idleTimeoutSeconds int
	maxActive          int
	wait               bool
	// 必填项目
	network  string
	address  string
	password string
}

// ClientOption 作为高阶函数的返回值，可以根据方法的不同进行多种操作
type ClientOption func(*ClientOptions)

// WithMaxIdle 设置最大空闲数量
func WithMaxIdle(maxIdle int) ClientOption {
	fmt.Println("1")
	return func(c *ClientOptions) {
		fmt.Println(4)
		c.maxIdle = maxIdle
	}
}

// WithIdleTimeoutSeconds 设置超时时间
func WithIdleTimeoutSeconds(idleTimeoutSeconds int) ClientOption {
	return func(c *ClientOptions) {
		c.idleTimeoutSeconds = idleTimeoutSeconds
	}
}

// WithMaxActive 设置最大激活链接
func WithMaxActive(maxActive int) ClientOption {
	return func(c *ClientOptions) {
		c.maxActive = maxActive
	}
}

// WithWaitMode 等待模型?
func WithWaitMode() ClientOption {
	return func(c *ClientOptions) {
		c.wait = true
	}
}

// repairClient Client 默认设置
func repairClient(c *ClientOptions) {
	if c.maxIdle < 0 {
		c.maxIdle = DefaultMaxIdle
	}

	if c.idleTimeoutSeconds < 0 {
		c.idleTimeoutSeconds = DefaultIdleTimeoutSeconds
	}

	if c.maxActive < 0 {
		c.maxActive = DefaultMaxActive
	}
}

// ---------------------------------------------------------------------------------------------------------------------

// LockOptions 锁配置文件
type LockOptions struct {
	// 是否阻塞
	isBlock bool
	// 阻塞等待时间
	blockWaitingSeconds int64
	// 锁过期时间
	expireSeconds int64
}

// LockOption 高阶函数返回值
type LockOption func(options *LockOptions)

// WithBlock 设置阻塞
func WithBlock() LockOption {
	return func(o *LockOptions) {
		fmt.Println("设置阻塞成功...")
		o.isBlock = true
	}
}

// WithBlockWaitingSeconds 设置阻塞等待时间
func WithBlockWaitingSeconds(blockWaitingSeconds int64) LockOption {
	return func(options *LockOptions) {
		options.blockWaitingSeconds = blockWaitingSeconds
	}
}

// WithExpireSeconds 设置锁的过期时间
func WithExpireSeconds(expireSeconds int64) LockOption {
	return func(options *LockOptions) {
		options.expireSeconds = expireSeconds
	}
}

// repairLock Lock默认设置
func repairLock(options *LockOptions) {
	if options.isBlock && options.blockWaitingSeconds <= 0 {
		// 等待时间为5s
		options.blockWaitingSeconds = 5
	}
	if options.expireSeconds <= 0 {
		// 过期时间为30s
		options.expireSeconds = 30
	}
}

redisLock 分布式锁具体实现文件

  1. ErrLockAcquiredByOthers 锁获取失败的返回值
  2. IsRetryableErr 判断是否继续获取
  3. RedisLock
    1. 继承LockOptions
    2. key 锁名
    3. token 取锁人
    4. client 客户端，用于获取线程池
  4. NewRedisLock 创建锁
  5. Lcok 加锁
  6. tryLock 获取锁
  7. getLockKey 返回锁名
  8. blockingLick 轮询锁
  9. UnLock 解锁
package redisLock

import (
	"context"
	"errors"
	"fmt"
	"time"
)

const RedisLockKeyPrefix = "REDIS_LOCK_PREFIX_"

// LuaCheckAndDeleteDistributionLock 判断是否拥有分布式锁的归属权，是则删除
const LuaCheckAndDeleteDistributionLock = `
  local lockerKey = KEYS[1]
  local targetToken = ARGV[1]
  local getToken = redis.call('get',lockerKey)
  if (not getToken or getToken ~= targetToken) then
    return 0
  else
    return redis.call('del',lockerKey)
  end
`

// ErrLockAcquiredByOthers no use lock error
var ErrLockAcquiredByOthers = errors.New("lock is acquired by others")

// IsRetryableErr is return err and no use lock error
func IsRetryableErr(err error) bool {
	return errors.Is(err, ErrLockAcquiredByOthers)
}

// RedisLock is Lock Type
type RedisLock struct {
	LockOptions
	// LockName
	key string
	// useLockUser
	token string
	// use RedisClient
	client *Client
}

// NewRedisLock 创建锁
func NewRedisLock(key string, client *Client, opts ...LockOption) *RedisLock {
	r := RedisLock{
		key:    key,
		client: client,
		// 工具生成token
		token: GetProcessAndGoroutineIDStr(),
	}

	for _, opt := range opts {
		opt(&r.LockOptions)
	}
	// 默认参数设置
	repairLock(&r.LockOptions)

	fmt.Println("创建锁成功...", r.GetToken())

	return &r
}

// Lock 加锁
func (r *RedisLock) Lock(ctx context.Context) error {
	// 尝试获取锁
	err := r.tryLock(ctx)
	// 不存在锁，加锁成功，直接返回
	if err == nil {
		return nil
	}
	// 加锁失败进行下面判断

	// 非阻塞模式加锁失败直接返回错误
	if !r.isBlock {
		return err
	}

	// 判断错误是否可以允许重试，不可允许的类型则直接返回错误
	if !IsRetryableErr(err) {
		return err
	}

	// 基于阻塞模式持续轮询取锁
	return r.blockingLock(ctx)
}

func (r *RedisLock) GetToken() string {
	return r.token
}

// 获取锁
func (r *RedisLock) tryLock(ctx context.Context) error {
	// 首先查询锁是否属于自己
	reply, err := r.client.SetNEX(ctx, r.getLockKey(), r.token, r.expireSeconds)
	// 返回失败则获取失败
	if err != nil {
		return err
	}
	// 返回不等于1，则表示存在锁
	if reply != "OK" {
		return fmt.Errorf("reply: %d, err: %w", reply, ErrLockAcquiredByOthers)
	}
	if reply == "OK" {
		fmt.Println("加锁成功")
	}
	return nil
}

// 返回锁名
func (r *RedisLock) getLockKey() string {
	// 拼接锁名
	return RedisLockKeyPrefix + r.key
}

// 轮询取锁
func (r *RedisLock) blockingLock(ctx context.Context) error {
	// 阻塞模式等锁时间上限，After在等待时间结束后向通道发送当前时间，计时器
	timeoutCh := time.After(time.Duration(r.blockWaitingSeconds) * time.Second)
	// 轮询 ticker，每隔 50 ms 尝试取锁一次,每个时间间隔发送一次时间
	ticker := time.NewTicker(time.Duration(50) * time.Millisecond)
	defer ticker.Stop()
	i := 1
	for range ticker.C {
		select {
		// ctx 终止了
		case <-ctx.Done():
			return fmt.Errorf("lock failed, ctx timeout, err: %w", ctx.Err())
			// 阻塞等锁达到上限时间
		case <-timeoutCh:
			return fmt.Errorf("block waiting time out, err: %w", ErrLockAcquiredByOthers)
		// 拦截上下文过期时间和阻塞上限时间，不拦截轮询，则在轮询发送信息的时候会跳过两个判断进行default操作，尝试取锁
		// 放行
		default:
		}
		i = i + 1
		// 尝试取锁
		fmt.Println("尝试取锁", i)
		err := r.tryLock(ctx)
		if err == nil {
			// 加锁成功，返回结果
			return nil
		}
		fmt.Println("取锁失败")

		// 不可重试类型的错误，直接返回
		if !IsRetryableErr(err) {
			return err
		}
	}

	return nil
}

// Unlock 解锁. 基于 lua 脚本实现操作原子性.
func (r *RedisLock) Unlock(ctx context.Context) error {
	// 获取锁名 + 用户id
	keysAndArgs := []interface{}{r.getLockKey(), r.token}
	/*
	  local lockerKey = KEYS[1]
	  local targetToken = ARGV[1]
	  local getToken = redis.call('get',lockerKey)
	  if (not getToken or getToken ~= targetToken) then
	    return 0
	  else
	    return redis.call('del',lockerKey)
	  end
	*/
	reply, err := r.client.Eval(ctx, LuaCheckAndDeleteDistributionLock, 1, keysAndArgs)
	if err != nil {
		return err
	}

	if ret, _ := reply.(int64); ret != 1 {
		return errors.New("can not unlock without ownership of lock")
	}
	return nil
}

使用方法演示

// main 使用 redisLock
func main() {
	// 创建客户端
	client := redisLock.NewClient("tcp", "127.0.0.1:6379", "")

	// 创建上下文
	ctx := context.Background()

	// 创建锁
	lock1 := redisLock.NewRedisLock("test_key", client, redisLock.WithBlock(),
		redisLock.WithBlockWaitingSeconds(5), redisLock.WithExpireSeconds(5))
	// 创建阻塞锁
	lock2 := redisLock.NewRedisLock("test_key", client, redisLock.WithBlock(),
		redisLock.WithBlockWaitingSeconds(10), redisLock.WithExpireSeconds(1))

	// WaitGroup等待一組go routine完成。主goroutine調用Add來設置要等待的goroutine的数量。
	// 然後每一個goroutine運行並在完成時調用Done。
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("lock1 开始获取锁")
		if err := lock1.Lock(ctx); err != nil {
			fmt.Println("lock1", err)
			return
		}
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("lock2 开始获取锁")
		if err := lock2.Lock(ctx); err != nil {
			fmt.Println("lock2", err)
			return
		}
	}()

	wg.Wait()

}
DDDerek~
关注
  • 21
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于go和redis实现分布式锁
10-14
基于go和redis实现分布式锁，使用了看门狗和红锁
redislock:使用Redis简化分布式锁实现
07-24
使用简化分布式锁定实现。 有关更多信息，请参阅示例。 例子 import ( "fmt" "time" "github.com/bsm/redislock" "github.com/go-redis/redis/v8" ) func main () { // Connect to redis. client := redis ....
golang redis实现分布式锁
王仁一的博客
03-08 1252
golang redis实现分布式锁
golang使用redis实现分布式锁
liyunlonghere
05-04 5801
redis可以使用string数据结构来实现分布式锁。这里记录一些注意点： setnx：利用setnx的特性，当key不存在时，可以设置成功；当key存在时，setnx返回nil。 设置expire：为了防止客户端获取到锁后忘记解锁，这里设置了锁的过期时间。并且由redis来保证setnx和expire是原子操作，否则可能出现在setnx后可能未设置expire的情况。 超时问题：由于设置了...
Golang实现Redis分布式锁解决秒杀问题
sunriseYJP的博客
08-07 891
登录是通过2个字段，一个是mobile，一个是password，生成了mobile从1到2000，密码默认是123456。我们使用有缓冲的通道和sync.WaitGroup信号量，来控制协程的数量在2000个以内。然后写一个单元测试，实现新注册的2000个用户登录，然后获取token。先写一个脚本sql，插入2000个用户。
Golang基于Redis实现分布式读写锁
fwhezfwhez的博客
03-07 1148
package redistool import ( "github.com/fwhezfwhez/errorx" "github.com/garyburd/redigo/redis" "time" ) type RedisRWMutex struct { key string maxlocksecond int // 锁定状态标记的最大时间 maxretryTimes int // 最大阻塞重试次数 retryInteval
Go语言实现Redis分布式锁
m0_57408211的博客
04-04 1101
本文将基于go语言，使用了一个常用的go Redis客户端一步一步探索与实现一个简单的Redis分布式锁。SETNX 命令用于在Redis中设置某个不存在的键的值。如果该键不存在，则设置成功，如果该键存在，则设置失败，不作任何动作。基于此可以实现一种简单的抢占机制。先连接redis。新建lock.go文件。创建lock结构体，加锁和解锁方法。
Go使用redigo实现简单分布式锁
lsj1342的博客
12-08 1522
redis分布式锁是 基于setnx的 只在键 key 不存在的情况下， 将键 key 的值设置为 value 。 若键 key 已经存在， 则 SETNX 命令不做任何动作。 SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。 此处采用了 redigo 实现， 代码如下： package main import ( "log" "time" "github.com/gomodule/redigo/redis" ) // 初始redis函数 func Init
golang使用redis分布式锁，缓存实现GetSet
qq_39272466的博客
11-14 107
【代码】golang使用redis分布式锁，匿名回调方式获取缓存。
golang使用redis分布式锁
热门推荐
万彬学习的博客
09-19 1万+
昨天由于项目需求，需要使用redis分布式锁，在网上找了半天，也没有找到一个简单的教程，经过自己研究，了解简单使用方法，都可以直接拿过来自己用，下面我就发出来给大家分享一下。 首先下载 github.com/garyburd/redigo，因为这个分布式锁是根据上面所实现； 下载 gopkg.in/redsync.v1这个就是实现分布式锁的源代码（如果测试需要下载 github.c...
golang使用redis分布式锁 [2020年更新]
万彬学习的博客
05-15 4284
我还记得上一篇文章golang使用redis分布式锁还是18年写的，但是对于现在来说已经不适用，所以今天我更新了go使用redis分布式锁，对想用redis分布式锁的人一个简单的讲解，并快速用于实践。 首先，最需要的还是redis的go客户端github.com/gomodule/redigo 已经不是之前的那个路径了。 然后下载github.com/go-redsync/redsync这个库，他就是实现分布式锁的核心。 当然你也可以自己实现，但是我今天只说这个库的用法。 // A Mute...
golang实现Redis分布式自旋锁+本地自旋锁
01-20
golang使用redis的setnx实现了一个自选锁，有key超时，同时也有我们调用redis链接时的超时。 package locker import ( context github.com/go-redis/redis runtime time ) type Lock struct { resource string...
golang go-redis和redigo的不同用法
01-08
目前Star最多的莫属于redigo 下面是基本用法 github.com/garyburd/redigo/redis func main() { conn,err := redis.Dial(tcp,10.1.210.69:6379) if err != nil { fmt.Println(connect redis error :,err) ...
jobor:基于golang redis实现的分布式定时任务，支持API，shell，python，go等任务类型
04-01
就业者 火星计划之定时任务
6.2 Go 切片（Slice）
最新发布
stormsha
05-29 1121
Go 语言以其简洁、高效和并发友好的特性，赢得了开发者的青睐。在 Go 中，切片（Slice）是一种动态数组，它不仅提供了数组的便利性，还具有灵活性和强大的功能。对于中高级开发者来说，掌握 Go 切片的使用技巧，可以大幅提升编程效率和程序性能。本文将深入探讨 Go 切片的高级使用技巧，帮助开发者更深入地理解和运用这一强大的数据结构。
深入了解 Golang 多架构编译：交叉编译最佳实践
xcbeyond|疯狂源自梦想，技术成就辉煌
05-26 829
通过这篇文章，读者可以全面了解 Golang 的多架构编译功能，掌握如何使用这一功能来实现跨平台部署。同时，通过最佳实践示例，读者可以更加直观地理解 Golang 多架构编译的实际应用场景，为日后的开发工作提供参考和指导。
Android USB调试模式下自动上下滑动（Go实现）
听我一言的博客
05-28 597
Golang实现通过ADB控制手机自动上下滑动
golang 实现redis分布式锁
05-02
实现 Redis 分布式锁的基本思路是利用 Redis 的 SETNX 命令（SET if Not eXists）实现。SETNX 命令会在 key 不存在的情况下，将 key 的值设为 value，如果 key 已经存在，则不做任何操作。 以下是一个简单的 Golang 实现 Redis 分布式锁的代码示例： ```go package redislock import ( "fmt" "time" "github.com/go-redis/redis/v7" ) type RedisLock struct { redisClient *redis.Client key string value string expiration time.Duration } func NewRedisLock(redisClient *redis.Client, key, value string, expiration time.Duration) *RedisLock { return &RedisLock{ redisClient: redisClient, key: key, value: value, expiration: expiration, } } func (r *RedisLock) Lock() (bool, error) { success, err := r.redisClient.SetNX(r.key, r.value, r.expiration).Result() if err != nil { return false, err } return success, nil } func (r *RedisLock) Unlock() error { err := r.redisClient.Del(r.key).Err() if err != nil { return err } return nil } ``` 在上面的代码中，NewRedisLock 函数用于创建一个 RedisLock 实例，需要传入 Redis 客户端、锁的 key、锁的值、锁的过期时间。Lock 方法用于尝试获取锁，如果获取成功，返回 true，否则返回 false。Unlock 方法用于释放锁。 以下是一个简单的使用示例： ```go package main import ( "fmt" "time" "github.com/go-redis/redis/v7" "github.com/yourusername/redislock" ) func main() { redisClient := redis.NewClient(&redis.Options{ Addr: "localhost:6379", DB: 0, }) lock := redislock.NewRedisLock(redisClient, "my-lock", "my-value", 10*time.Second) success, err := lock.Lock() if err != nil { fmt.Println("failed to acquire lock:", err) return } if !success { fmt.Println("lock is already held by another process") return } defer lock.Unlock() // Do some work } ``` 在上面的示例中，我们创建了一个 Redis 客户端，并且创建了一个 RedisLock 实例。然后，我们调用 Lock 方法尝试获取锁，如果获取成功，就可以进行一些需要加锁的操作。最后，我们调用 Unlock 方法释放锁。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值