golang 并发同步（sync 库）-- 单例模式的实现（六）

已于 2022-09-04 19:47:07 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： golang 系列 文章标签： 单例模式 golang 线程安全 sync 锁
于 2022-09-04 19:31:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjf147369/article/details/126693162
版权

文章目录


在前面章节 golang 并发–goroutine（四）我们讲过 golang 是天生支持高并发的语言。那么有并发必然涉及到线程安全的问题，为了防止多个 go 程同时操作同一个临界资源，我们必然需要引入锁，golang 内置库 sync 就是为我们提供锁的操作方法的。这篇文章我们通过一些例子来看一看 sync 库怎么用。

golang 单例模式

单例模式是常见的一种设计模式，学习过 java 的伙伴们应该知道单例模式可以保障在一个程序中一个类只实例化一个对象。在 golang 中没有类和对象的概念，但是存在类似的概念 struct （结构体），golang 单的例模式的就是保证一个结构体只能实例化出一个变量。

下面我们就先通过实现一个 golang 单例模式来学习 sync 库的用法。

非线程安全的单例模式

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

var mu sync.Mutex
var instance *testStruct
var num int = 0

func NewTestSturct() *testStruct {
    if instance == nil {
        num++
        time.Sleep(500 * time.Millisecond)
        instance = &testStruct{num: num}
    }
    return instance
}

func createAndCheckSingleton() {
    ins := NewTestSturct()
    fmt.Printf("ins 的地址为 %p, ins 的 num 属性值期望为 1，实际为 %d\n", ins, ins.num)
}

func main() {
    go createAndCheckSingleton()
    go createAndCheckSingleton()
    time.Sleep(1 * time.Second)
}

上面代码看似没问题，但是我们执行一下，看输出结果：

ins 的地址为 0xc000184000, ins 的 num 属性值期望为 1，实际为 2
ins 的地址为 0xc000094000, ins 的 num 属性值期望为 1，实际为 2

我们并不能得到我们期望的输出，这是因为 NewTestSturct 函数比较耗时，在 testStruct 还没完全初始化时别的 go 程再次调用了这个函数。

注意：上面两个 time.Sleep，第一个 time.Sleep 是为了模拟耗时长的临界资源操作，第二个 time.Sleep 是为了防止主 go 程过早退出。

加锁的单例模式

为了解决上面的问题我们可以用 sync.Mutex 在执行 NewTestSturct 时加锁，看下面代码：

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

var mu sync.Mutex
var instance *testStruct
var num int = 0

func NewTestSturct() *testStruct {
    mu.Lock()
    defer mu.Unlock()
    if instance == nil {
        num++
        time.Sleep(500 * time.Millisecond)
        instance = &testStruct{num: num}
    }
    return instance
}

func createAndCheckSingleton() {
    ins := NewTestSturct()
    fmt.Printf("ins 的地址为 %p, ins 的 num 属性值期望为 1，实际为 %d\n", ins, ins.num)
}

func main() {
    go createAndCheckSingleton()
    go createAndCheckSingleton()
    time.Sleep(1 * time.Second)
}

输出结果：

ins 的地址为 0xc000180000, ins 的 num 属性值期望为 1，实际为 1
ins 的地址为 0xc000180000, ins 的 num 属性值期望为 1，实际为 1

通过加锁的方式，确保了 NewTestSturct 不会在多个 go 程中并发运行，这次我们得到了我们想要的结果。

sync.Once 更优雅的方式实现单例模式

单例模式就是结构体的初始化只被执行一次，其实 golang 的 sync.Once 已经为我们实现了这个机制，下面直接看代码：

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

var once sync.Once
var instance *testStruct
var num int = 0

func NewTestSturct() *testStruct {
    once.Do(func() {
        num++
        time.Sleep(500 * time.Millisecond)
        instance = &testStruct{num: num}
    })
    return instance
}

func createAndCheckSingleton() {
    ins := NewTestSturct()
    fmt.Printf("ins 的地址为 %p, ins 的 num 属性值期望为 1，实际为 %d\n", ins, ins.num)
}

func main() {
    go createAndCheckSingleton()
    go createAndCheckSingleton()
    time.Sleep(1 * time.Second)
}

sync.Once.Do 的参数是一个函数，对于同一个 sync.Once 的变量 once 无论调用多少次 once.Do 只有第一次调用是执行了其参数传递进来的函数的。

输出结果：

ins 的地址为 0xc000100000, ins 的 num 属性值期望为 1，实际为 1
ins 的地址为 0xc000100000, ins 的 num 属性值期望为 1，实际为 1

更优雅的方式防止主 go 程提前退出

在上面的例子中我使用了 time.Sleep 来防止主 go 程在其他 go 程还没运行完的情况下提前结束，其实这是一种非常非常笨拙的方式，我们没法准确的把握需要 sleep 的时间，强烈建议大家不要在正式代码中这么使用。

接下面我们介绍一个优雅的方法 sync.WaitGroup，我们直接看示例代码：

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

func testWaitGroup(wg *sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(1 * time.Second)
    fmt.Println("子 go 程已经执行完毕，我的父 go 程可以退出了")
}

func main() {
    var wg sync.WaitGroup = sync.WaitGroup{}
    wg.Add(1)
    go testWaitGroup(&wg)
    wg.Wait()
}

输出结果：

 go 程已经执行完毕，我的父 go 程可以退出了

看见没，这里我们就没用 sleep，而且父 go 程也能及时的知道子 go 程执行完成了。但是在使用 sync.WaitGroup 时有两点需要特别注意：

1、wg.Add(1) 这个语句如果放在子 go 程函数开始的位置可以吗？我们来直接看例子：

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

func testWaitGroup(wg *sync.WaitGroup) {
    wg.Add(1)
    defer wg.Done()
    time.Sleep(1 * time.Second)
    fmt.Println("子 go 程已经执行完毕，我的父 go 程可以退出了")
}

func main() {
    var wg sync.WaitGroup = sync.WaitGroup{}
    go testWaitGroup(&wg)
    wg.Wait()
}

我们运行这个代码会发现它没有任何输出。这是怎么回事呢？答案就是wg.Add(1) 在子 go 程中根本就没有机会执行，因为在系统调度执行子 go 程前，其父 go 程就已经结束了。

2、函数 testWaitGroup 的参数能不使用指针吗？还是直接看例子：

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

func testWaitGroup(wg sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(1 * time.Second)
    fmt.Println("子 go 程已经执行完毕，我的父 go 程可以退出了")
}

func main() {
    var wg sync.WaitGroup = sync.WaitGroup{}
    wg.Add(1)
    go testWaitGroup(wg)
    wg.Wait()
}

输出结果：

子 go 程已经执行完毕，我的父 go 程可以退出了
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [semacquire]:
sync.runtime_Semacquire(0xc000016180?)
        /usr/local/go/src/runtime/sema.go:56 +0x25
sync.(*WaitGroup).Wait(0x0?)
        /usr/local/go/src/sync/waitgroup.go:136 +0x52
main.main()
        /root/yjfwk/testgo/main.go:23 +0x7d
exit status 2

可以看到在子 go 程执行结束后，程序抛出了 deadlock 的异常。这是为什么呢？其实答案就隐藏在我之前的文章中：golang 函数参数传递–指针，引用和值（二）。

因为 sync.WaitGroup 是一个结构体，结构体是一个值类型的变量，在函数参数传递中值类型的变量会发送 copy，也就是说不使用指针子 go 程和父 go 程的的 wg 已经不是同一个了，在子 go 程中执行 wg.Done() 并不会影响到其父 go 程，因此子 go 程退出后父 go 程还继续尝试等待但是系统系统检测到没有其他 go 程了等下去是无意义的，所以就抛出了异常。

sync.Cond–golang 指挥家

我们应该注意到一个特点 golang 创建要给新的 go 程没有任何返回，这里多进程和多线程不一样，以多进程为例，父进程调用 fork 函数创建子进程时，父进程会得到子进程的进程号，后续父进程就可以通过这个进程号控制子进程了。golang 并没有这样的机制，但是 golang 有很多其他办法到达 go 程相互影响的效果。sync.Cond 就是其中之一，Cond 是 conductor 的简写，直译为指挥家，从这里也可以大概猜出来 sync.Cond 作用，sync.Cond 有三个方法：Wait，Signal，Broadcast。调用 Wait 会使 go 程阻塞陷入等待直到收到其他go 程发出的信号；Signal 用于发送信号，如果有多个 go 程阻塞陷入等待，Signal 只会解除其中一个的等待状态；Broadcast 也是用于发送信号的，但是 Broadcast 发送的信号会被所有陷入阻塞的 go 程收到。下面我们直接看例子：

package main

import (
    "fmt"
    "sync"
    "time"
)

type testStruct struct {
    num int
}

func testWaitGroup(wg *sync.WaitGroup, conductor *sync.Cond) {
    defer wg.Done()
    conductor.L.Lock()
    defer conductor.L.Unlock()
    fmt.Printf("%s 等待信号\n", time.Now().Format("2006-01-02 15:04:05"))
    conductor.Wait()
    fmt.Printf("%s 收到信号\n", time.Now().Format("2006-01-02 15:04:05"))
}

func main() {
    var wg sync.WaitGroup
    conductor := sync.NewCond(&sync.Mutex{})
    wg.Add(3)
    go testWaitGroup(&wg, conductor)
    go testWaitGroup(&wg, conductor)
    go testWaitGroup(&wg, conductor)
    time.Sleep(5 * time.Second)
    conductor.Broadcast()
    wg.Wait()
}

输出结果：

2022-09-02 11:52:26 等待信号
2022-09-02 11:52:26 等待信号
2022-09-02 11:52:26 等待信号
2022-09-02 11:52:31 收到信号
2022-09-02 11:52:31 收到信号
2022-09-02 11:52:31 收到信号

读者可以自己吧 conductor.Broadcast() 换成 conductor.Signal() 试一试。

注意：和 sync.WaitGroup 一样 sync.Cond 在初始化后不能被 copy，因此作为函数参数时只能用指针。

sync 中的其他方法

  • sync.RWMutex 是在 sync.Mutex 基础上进行扩展，把锁分成了读锁和写锁：读锁可以被多个 go 程申请，go 程不会陷入阻塞，但是只要有一个 go 程持有了读锁，那么任意 go 程申请写锁都会陷入阻塞；写锁只能同时被一个 go 程持有，当有一个 go 程持有写锁，其他 go 程申请写锁或者读锁都会陷入阻塞。感觉比较容易理解，这里就不写代码演示了。

  • sync.Map 可以理解为是对 golang map 类型的一个扩展，它提供了几个方法保证了 sync.Map 是线程安全的，多个 go 程可以放心的对同一个 sync.Map 变量进行操作
    在这里插入图片描述

    上图这些方法也是比较好理解的，这里就不单独写示例了，如果读者其中的某些方法有疑惑，可以在评论区留言。

  • sync.Pool 这个在之前的文章中专门介绍过，其是用于减少系统 gc，提高系统性能的，感兴趣的读者可以参考：golang 内存那些事–如何快速分配内存，减少系统 GC （三）

muyige0852
关注
专栏目录
Go 学习笔记（66）— Go 并发同步原语（sync.Mutex、sync.RWMutex、sync.Once）及并发模型（ping-pong 模式、fan-in 模式、fan-out 模式）
wohu1104的专栏
11-28 971
1. 竞态条件 一旦数据被多个线程共享，那么就很可能会产生争用和冲突的情况。这种情况也被称为竞态条件（race condition），这往往会破坏共享数据的一致性。 举个例子，同时有多个线程连续向同一个缓冲区写入数据块，如果没有一个机制去协调这些线程的写入操作的话，那么被写入的数据块就很可能会出现错乱。 比如，在线程 A 还没有写完一个数据块的时候，线程 B 就开始写入另外一个数据块了。 显然，这两个数据块中的数据会被混在一起，并且已经很难分清了。因此，在这种情况下，我们就需要采取一些措施来协调它们对缓冲区
Go单例模式理解
lonelyVM的博客
02-20 228
对于被Go语言天生支持并发的特性吸引来的跨语言学习者来说，我觉着掌握Go语言的语法并不是最难的，最难的是突破既有的思维定势，真正理解并发和使用并发来解决实际问题。 Go语言太容易实现并发了，以至于它在很多地方被不正确的使用了。 常见的错误 有一些错误是很常见的，比如不考虑并发安全的单例模式。就像下面的示例代码： package singleton type singleton struct {} var instance *singleton func GetInstance() *singleton
【Go】Golang Sync包
藏经阁 | 玄苦
05-30 4002
一. 前言 Golang sync包提供了基础的异步操作方法，包括互斥锁Mutex，执行一次Once和并发等待组WaitGroup。 本文主要介绍sync包提供的这些功能的基本使用方法。 Mutex: 互斥锁 RWMutex：读写锁 WaitGroup：并发等待组 Once：执行一次 Cond：信号量 Pool：临时对象池 Map：自带锁的map 二. sync.Mutex sync.Mute...
golang并发同步（启动与结束）
weixin_54941936的博客
10-16 207
接收任意数据，忽略接收的数据： <-ch 使用通道做并发同步的写法： func main() { //构建通道 ch := make(chan int) //并发匿名函数 go func() { fmt.Println("start" + time.Now().String()) //延迟1秒向通道发送数据 time.Sleep(1e9) ch <- 0 fmt.Println("exit" + time.Now().String()) }() fm
golang并发之sync包
OceanStar的博客
07-10 863
在Go语言并发编程中，提倡**“使用通信共享内存，不要使用共享内存通信”**，而这个通信的媒介就是channel。 chan是线程安全的，不需要考虑数据冲突问题，面对并发问题，我们始终应该优先考虑使用通道，它是 first class 级别的，但是纵使有主角光环加持，通道也不是万能的，它也需要配角，这也是共享内存存在的价值，其他语言中主流的并发编程都是通过共享内存实现的，共享内存必然涉及并发过程中的共享数据冲突问题，而为了解决数据冲突问题，Go 语言沿袭了传统的并发编程解决方案 —— 锁机制，这些锁都位于.
golang 实现并发任务同步
技术的搬运工
11-11 294
当某个请求同时开启多个任务时，为了保证在请求关闭前任务都能正常完成，可以利用sync包。
golang 并发之后同步
@奮 鬥@的专栏
03-22 910
// Synchronization 一个并发执行器, 并发的执行N个任务 // 等待所有任务返回结果，然后在做统一的处理 func Synchronization(args ...func()) { // 创建N个管道，管道用来接收各个并发的任务的完成 n := len(args) chs := make([]chan int, n) defer func() { for _, c ...
Golang 并发&同步的详细原理和使用技巧
后端系统和架构
11-25 1893
Golang 并发&同步的详细原理和使用技巧
golang-concurrency-patterns:Go 并发模式
07-05
可以使用 `sync.WaitGroup` 实现这一模式，它允许主 goroutine 等待一组并发任务完成。 8. ** 单例（Singleton）**： 在并发环境中确保一个变量只被初始化一次，可以使用通道和互斥锁来实现。通过一个关闭的通道...
golang-design-patterns:Golang中的模式集合
04-19
1. **单例模式**：在Go中，我们可以使用全局变量配合sync.Once来实现单例，确保一个类型只有一个实例，并提供全局访问点。这在管理共享资源如数据库连接池时非常有用。 2. **工厂模式**：Go中的工厂模式通常通过...
Go-Gopli–采用Golang编写的DB数据同步复制工具
08-13
Gopli – 采用Golang编写的DB数据同步复制工具
[Go]Golang中控制并发的sync包
程序员老狼专注开发aigc或客服系统应用
03-09 115
sync包中包含了对安全的并发访问资源的方式 ， 包含了以下 Mutex：互斥锁RWMutex：读写锁WaitGroup：等待组Once：单次执行Cond：信号量Pool：临时对象池Map：自带锁的map 1.互斥锁 互斥锁需要确保的是某段时间内，不能有多个协程同时访问一段代码(临界区)，互斥锁被称为Mutex，它有2个函数，Lock()和Unlock()分别是获取锁和释放锁 Mutex的初始值...
golang sync
m0_48723204的博客
03-10 208
【代码】golang sync。
golang标准库-sync包使用和应用场景
go go go
05-15 1091
sync包    标准库中的sync包在我们的日常开发中用的颇为广泛，那么大家对sync包的用法知道多少呢，这篇文章就大致讲一下sync包和它的使用 Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level li
GOLANG sync.Once
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
06-05 6144
对于从全局的角度只需要运行一次的代码，比如全局初化操始作，go语言提供了一个Once类型来保证全局的唯一性操作。 type Once Once is an object that will perform exactly one action. type Once struct { // contains filtered or unexported fields }
golang--sync包
Freeman_23的博客
05-20 614
本文将详细介绍sync包中常用的几个类型和函数，包括互斥锁、读写锁、条件变量和等待组，帮助你更好地理解和应用sync包。通过本文的介绍，你应该对sync包中的互斥锁、读写锁、条件变量和等待组有了更深入的理解。互斥锁（Mutex）是最常用的同步机制，用于保护临界区，防止多个goroutine同时访问共享资源，保证数据的一致性。sync包中的Mutex类型提供了互斥锁的基本操作。使用sync.Mutex声明一个互斥锁变量，然后通过Lock方法获取锁，使用defer延迟解锁，确保即使发生异常，也能释放锁。
Golang sync包的使用
稻草人技术博客
11-16 2141
Desc:Go sync 包的使用方法，sync.Mutex，sync.RMutex，sync.Once，sync.Cond，sync.Waitgroup 尽管 Golang 推荐通过 channel 进行通信和同步，但在实际开发中 sync 包用得也非常的多。另外 sync 下还有一个 atomic 包，提供了一些底层的原子操作（这里不做介绍）。本篇文章主要介绍该包下的锁的一些概念及使用方法。 ...
Golang sync简述
qq_37112905的博客
08-16 412
Golang sync模块 sync.map类型是在Go1.9加入的，实现的是一个线程安全的map,它和map在使用上有着多方面的不同 首先是定义上不需要使用make来创建内存资源，而是直接定义后使用如:var syncMap sync.Map syncMap.Load(key)(value,ok)，Load是sync.Map中获取Value的方法，在sync.Map中key，value都是i...
golang sync包
Geek猫的专栏
12-08 166
sync.Pool  临时对象池 type Pool struct { // 可选参数New指定一个函数在Get方法可能返回nil时来生成一个值 // 该参数不能在调用Get方法时被修改 New func() interface{} // 包含隐藏或非导出字段 } Pool是一个可以分别存取的临时对象的集合。 Pool可以安全的被多个线程同时使用。...
golang 实现aes-128-gcm
最新发布
01-11
golang 提供了标准库 crypto/aes 来实现 AES 加密算法，同时也支持 gcm 模式。要实现 AES-128-GCM 加密，首先需要生成一个 128 位的密钥，并且创建一个 AES 实例来进行加密操作。接着还需要创建一个 gcm 实例来进行 gcm 模式的加密。 首先，可以使用 crypto/rand 包生成一个随机的 128 位密钥，代码如下： ``` key := make([]byte, 16) if _, err := rand.Read(key); err != nil { panic(err.Error()) } ``` 随后，可以使用 aes.NewCipher() 来创建一个 AES 实例，代码如下： ``` block, err := aes.NewCipher(key) if err != nil { panic(err.Error()) } ``` 然后，可以使用 cipher.NewGCM() 来创建一个 gcm 实例，代码如下： ``` gcm, err := cipher.NewGCM(block) if err != nil { panic(err.Error()) } ``` 最后，可以使用 gcm.Seal() 方法来进行 AES-128-GCM 加密操作，代码如下： ``` nonce := make([]byte, gcm.NonceSize()) if _, err = io.ReadFull(rand.Reader, nonce); err != nil { panic(err.Error()) } ciphertext := gcm.Seal(nonce, nonce, plaintext, nil) ``` 通过上面的步骤，就可以在 golang 中实现 AES-128-GCM 加密了。需要注意的是，在实际使用时，还需要对密钥进行妥善管理，以及对加密结果进行适当的存储和传输。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值