Golang有哪些常见的锁
时间: 2023-12-29 18:12:26 浏览: 24
Golang中常见的锁包括:Mutex、RWMutex、WaitGroup、Once等。其中Mutex是最基础、最常用的一种锁,适用于单个goroutine对共享资源的互斥访问。RWMutex和Mutex类似,但支持多个读操作,适用于读多写少的场景。WaitGroup用于等待一组goroutine全部完成执行后再继续执行接下来的代码。Once用于确保某个操作只执行一次。
相关问题
golang 实现redis分布式锁
实现 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 方法释放锁。
golang 如何加全局锁
在 Golang 中,可以使用 `sync` 包中的 `Mutex` 类型来实现全局锁。`Mutex` 可以保证同一时刻只有一个 goroutine 能够访问共享资源。
以下是一个使用 `Mutex` 实现全局锁的示例代码:
```go
package main
import (
"fmt"
"sync"
)
var globalVar int
var mutex = &sync.Mutex{}
func incrementGlobalVar() {
mutex.Lock()
globalVar++
mutex.Unlock()
}
func main() {
for i := 0; i < 10; i++ {
go incrementGlobalVar()
}
// 等待所有 goroutine 执行完毕
// 确保 globalVar 的值被全部累加
for globalVar < 10 {
}
fmt.Println(globalVar)
}
```
在上面的代码中,我们定义了一个 `Mutex` 类型的变量 `mutex`,并在 `incrementGlobalVar()` 函数中对 `globalVar` 变量进行加锁和解锁操作,确保同一时刻只有一个 goroutine 能够修改 `globalVar` 的值。
在 `main()` 函数中,我们启动了 10 个 goroutine 来并发执行 `incrementGlobalVar()` 函数,最终输出 `globalVar` 的值时,可以看到它的值为 10,说明所有的 goroutine 都成功地对 `globalVar` 进行了累加操作。