[Golang] Sync

于 2024-09-16 21:00:43 发布
阅读量691 收藏 14
点赞数 23
分类专栏： Golang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dev1cce/article/details/142307055
版权

[Golang] Sync

文章目录

Golang中我们一般提倡使用通信来共享内存，不使用共享内存来通信，比如Goroutine之间通过channel来协作。而其他语言中，都是通过共享内存加锁机制来保证并发安全的，同样的Golang中也提供对共享内存并发安全机制的支持，它们都在sync包中。

sync.WaitGroup

之前我们已经使用过sync.WaitGroup来替换time.Sleep，让一个协程等待一个协程执行完毕，也就是使用sync.WaitGroup来实现并发任务的同步以及协程任务等待。

使用方式：

sync.WaitGroup是一个对象，里面维护一个计数器，并通过三个方法来配合使用

  • (wg *WaitGroup) Add(delta int) 计数器加cnt

  • (wg *WaitGroup) Done() 计数器减1

  • (wg *WaitGroup) Wait() 阻塞代码运行，直到计数器减为0

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go myGoroutine(&wg)
	}
	wg.Wait()
}
func myGoroutine(wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("myGoroutine")
}

执行结果：

image-20240916175936050

先把计数器设置为10，每运行完一个myGoroutine就把计数器减1，main函数等待计数器值为0，也就是10个子协程打印完10个myGoroutine后，子协程全部退出，主协程才会退出。

ps：计数器的值不能减为负数，不然就会panic。

sync.Once

很多时候，程序中有很多逻辑只需要执行一次，比如配置文件的加载，我们只需要加载一次，让配置保存在内存中，下次直接使用内存中的配置文件即可，这时就会用到sync.Once。

sync.Once可以在代码的任意位置初始化和调用，并且线程安全。对于一个sync.Once变量我们并不会在程序启动时初始化，而是在第一次使用到它时才进行初始化，并且只初始化这一次，初始化后保存在内存中，这就很符合我们刚刚说到的配置文件加载的场景，这其实也就是单例模式中的懒汉模式。毕竟一开始就加载到内存中，长时间不用就浪费了内存。

package main

import (
	"fmt"
	"sync"
)

type Config struct{}

var instance *Config
var once sync.Once
var cnt int

func InitConfig() *Config {
	once.Do(func() {
		fmt.Printf("第%d次被调用", cnt)
		instance = &Config{}
	})
	return instance
}

func main() {
	cnt = 1
	InitConfig()
	InitConfig()
	go InitConfig()
	InitConfig()
	go InitConfig()
	InitConfig()
	InitConfig()

}

执行结果：

image-20240916181728455

只有第一次调用InitConfig()时获取Config指针时才会执行once.Do()语句，执行完后instance就保留在内存中了，后面再次执行时，会直接返回这个instance。

对比init()

  • init()：适用于程序启动时的初始化，确保在主函数执行前完成初始化任务。比如，日志配置初始化，在程序启动时配置日志文件。
  • sync.Once：适用于延迟初始化且在并发环境下只需要执行一次的初始化任务。比如，配置文件加载、数据库连接池初始化。

sync.Lock

并发编程中资源的竞争，Golang给出了两种解决方案：锁和原子操作。

package main

import (
    "fmt"
    "sync"
)

func main() {
    n := 10000
    sum := 0

    var wg sync.WaitGroup
    wg.Add(n)

    for i := 0; i < n; i++ {
       go func() {
          defer wg.Done()
          sum += 1
       }()
    }
    wg.Wait()
    fmt.Println(sum)
}

执行结果：

image-20240916182645164

最后10000个协程执行完之后，sum并不是1000，这就出现了并发问题。同一时间多个Goroutine对sum做+1操作，但是不是在在前一个协程执行完的基础上做的累加，这样前一个协程的执行就会被后一个协程的执行结果覆盖了。

互斥锁和读写锁

互斥锁

互斥锁：同一时间只允许一个goroutine对共享资源进行访问。

var lock sync.Lock
func (m *Mutex) Lock()		// 加锁
func (m *Mutex) UnLock()	// 解锁

我们对上面的代码稍加修改：

package main

import (
	"fmt"
	"sync"
)

func main() {
	n := 10000
	sum := 0

	var wg sync.WaitGroup
	wg.Add(n)
	mu := sync.Mutex{}

	for i := 0; i < n; i++ {
		go func() {
			mu.Lock()
			defer wg.Done()
			sum += 1
			mu.Unlock()
		}()
	}
	wg.Wait()
	fmt.Println(sum)
}

执行结果：

image-20240916183516253

注意：加锁之后不用忘记解锁，否则会造成其他goroutine一直阻塞。

读写锁

把读操作和写操作分离，一般用于大量读操作、少量写操作的情况。

var mr sync.RWMutex

func (rw *RWMutex) Lock()		// 对写锁加锁
func (rw *RWMutex) UnLock()		// 对写锁解锁

func (rw *RWMutex) RLock()		// 对读锁加锁
func (rw *RWMutex) RUnLock()	// 对读锁解锁

读写锁的使用：多个Goroutine可以同时读，但是只有一个Goroutine能写；共享资源要么在被一个或多个Goroutine读，要么在被一个Goroutine写，读写不能同时进行。

死锁问题

死锁：在两个以上的Goroutine执行过程中，因为争抢共享资源处于互相等待的状态，如果没有外部干涉将一直处于这个阻塞的状态。

加锁解锁不成对

这种场景一般是对锁进行拷贝的使用：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var mu sync.Mutex
	mu.Lock()
	defer mu.Unlock()
	copyMutex1(mu)
	copyMutex2(&mu)
	fmt.Println("main end...")
}
func copyMutex1(mu sync.Mutex) {
	mu.Lock()
	defer mu.Unlock()
	fmt.Println("copyMutex1 end...")
}
func copyMutex2(mu *sync.Mutex) {
	mu.Lock()
	defer mu.Unlock()
	fmt.Println("copyMutex2 end...")
}

执行结果：

image-20240916184736568

如果把带有锁结构的变量赋值给其他变量，锁的状态会复制。所以复制之后的锁已经有了原来的锁状态，那么copyMutex()中执行mu.Lock()会被一直阻塞，因为外面的main函数中已经Lock()过了一次但是还没有Unlock()。这就导致了copyMutex()内锁一直在等待Lock()，而main()内一直在等待解锁，这就导致了死锁。

所以在使用锁时，我们要避免拷贝锁，并且Lock()和UnLock要成对出现。

循环等待
package main

import (
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(2)
	var mu1, mu2 sync.Mutex
	go func() {
		defer wg.Done()
		mu1.Lock()
		defer mu1.Unlock()
		time.Sleep(time.Second)
		mu2.Lock()
		defer mu2.Unlock()
	}()
	go func() {
		defer wg.Done()
		mu2.Lock()
		defer mu2.Unlock()
		time.Sleep(time.Second)
		mu1.Lock()
		defer mu1.Unlock()
	}()
	wg.Wait()
}

执行结果：

image-20240916190424536

两个Goroutine在加第二个锁时，都会等待对方释放锁，造成了循环等待，一直阻塞，形成了死锁。

sync.Map

golang中内置的Map不是并发安全的，多个goroutine同时操作map时会有并发问题。

比如：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(10)

	mp := make(map[int]int)
	for i := 0; i < 10; i++ {
		go func(num int) {
			defer wg.Done()
			mp[num] = num + 1
			fmt.Printf("key=%v, value=%v", num, mp[num])
		}(i)
	}
	wg.Wait()
}

执行结果：

image-20240916192225248

说明内置的map不能并发操作。

解决方案1：

加锁：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(10)
	var mu sync.Mutex

	mp := make(map[int]int)
	for i := 0; i < 10; i++ {
		go func(num int) {
			defer wg.Done()
			mu.Lock()
			defer mu.Unlock()
			mp[num] = num + 1
			fmt.Printf("key=%v, value=%v\n", num, mp[num])
		}(i)
	}
	wg.Wait()
}

执行结果：

image-20240916192118056

解决方案2：

使用并发安全的map：sync.Map

比如：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var mp sync.Map
	// 1.写入
	mp.Store("name", "张三")
	mp.Store("age", 18)
	// 2.读取
	age, _ := mp.Load("age")
	fmt.Println(age.(int)) // 断言age为int类型
	// 3.遍历
	mp.Range(func(key, value any) bool {
		fmt.Printf("key = %v, value = %v\n", key, value)
		return true
	})
	// 4.删除
	mp.Delete("age")
	age, ok := mp.Load("age")
	fmt.Println(age, ok)
	// 5.读取或写入
	mp.LoadOrStore("name", "李四")
	name, _ := mp.Load("name")
	fmt.Printf("name = %v", name)
}

执行结果：

image-20240916193324191

sync/atomic

之前说了锁，现在说另一种解决并发安全的策略：atomic原子操作。

// T的类型为 int32、int64、uint32、uint64和uintptr的任意一种
func AddT(addr *T, delta T)(new T)
func StoreT(addr *T, val T)
func LoadT(addr *T) (val T)
func SwapT(addr *T, new T) (old T)
func CompareAndSwap(addr *T, old,new T) (swapped bool)

例如：

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(100)
	var num int32 = 0
	for i := 0; i < 100; i++ {
		go func() {
			defer wg.Done()
			atomic.AddInt32(&num, 1)
		}()
	}
	wg.Wait()
	fmt.Println(num)
}

执行结果：

image-20240916194456421

atomic和mutex的区别

使用方式：mutex通常用于保护一段代码执行逻辑；atomic一般用于对变量的操作

底层实现：mutex由操作系统调度器实现；atomic操作有底层硬件指令支持，保证cpu在执行上不中断。

atomic.value

atomic也支持了对struct这种复合类型进行原子操作。

比如：

package main

import (
	"fmt"
	"sync/atomic"
)

type Student struct {
	Name string
	Age  int
}

func main() {
	st1 := Student{
		Name: "张三",
		Age:  18,
	}
	st2 := Student{
		Name: "李四",
		Age:  20,
	}
	st3 := Student{
		Name: "王五",
		Age:  22,
	}
	var v atomic.Value
	v.Store(st1)             // 1.写入
	st := v.Load().(Student) // 2.读取
	fmt.Println(st)

	old := v.Swap(st2) // 3.交换
	st = v.Load().(Student)
	fmt.Println("after swap :", st)
	fmt.Println("old :", old)

	swapped := v.CompareAndSwap(st1, st3) // 4.比较并交换
	fmt.Println("交换: ", swapped)
	st = v.Load().(Student)
	fmt.Println(st)
	swapped = v.CompareAndSwap(st2, st3) // 4.比较并交换
	fmt.Println("交换: ", swapped)
	st = v.Load().(Student)
	fmt.Println(st)
}

执行结果：

image-20240916195800443

sync.Pool

sync.Pool是sync包下的一个内存池组件，用来实现对象的复用，避免重复创建相同的对象，造成频繁的内存分配和gc，以达到提升程序性能的目的。虽然池子中的对象可以被复用，但是sync.Pool并不会永久保存这个对象，池中的对象会在一定时间后被gc回收，这个时间是随机的。所以不能用sync.Pool来持久化存储对象。

如何使用

New()	// sync.Pool的构造函数，用于指定sync.Pool中缓存的数据类型，
		// 如果调用Get()时，池中没有元素就会调用New()方法创建一个新对象
Get()	// 从对象池取对象
Put()	// 向对象池中放对象，下次Get()时可以复用

例如：

package main

import (
	"fmt"
	"sync"
)

type Student struct {
	Name string
	Age  int
}

func main() {
	pool := sync.Pool{
		New: func() interface{} {
			return &Student{
				Name: "张三",
				Age:  18,
			}
		},
	}
    st := pool.Get().(*Student)			//(*Student)断言
	println(st.Name, st.Age)
	fmt.Printf("st addr = %p\n", st)
	pool.Put(st)

	st2 := pool.Get().(*Student)
	println(st2.Name, st2.Age)
	fmt.Printf("st addr = %p\n", st2)
}

执行结果：

image-20240916204315463

程序逻辑：

我们先初始化一个sync.Pool对象，初始化New()方法，用于创建对象，这里是返回一个*Student。

第一次调用Get()时，池中没有对象，所以会调用New()方法创建一个，由于返回类型为interface{}所以需要我们断言一下

使用完后，再调用Put()方法，把对象放回池中，再调用pool.Get取对象，此时我们可能看到的对象地址是同一个，如果看到同一个说明sync.Pool有缓存对象的功能。

ps：由于 sync.Pool 的设计是为了在高并发环境下工作，它的行为可能不是完全可预测的。在某些情况下，即使你将对象放回了池中，下次获取时也可能得到一个新的对象。

一般我们如果在修改对象字段后，回收前记得Reset，否则取到的对象是同一个，但是字段内容变化了。

比如：

package main

import (
	"fmt"
	"sync"
)

type Student struct {
	Name string
	Age  int
}

func main() {
	pool := sync.Pool{
		New: func() interface{} {
			return &Student{
				Name: "张三",
				Age:  18,
			}
		},
	}
	st := pool.Get().(*Student)
	println(st.Name, st.Age)
	fmt.Printf("st addr = %p\n", st)
	
    // 修改
	st.Name = "李四"
	st.Age = 20

	pool.Put(st)

	st2 := pool.Get().(*Student)
	println(st2.Name, st2.Age)
	fmt.Printf("st2 addr = %p\n", st2)
}

执行结果：

image-20240916204503090

sync.Pool没有提供Reset函数，一般需要我们进行手写：

package main

import (
	"fmt"
	"sync"
)

type Student struct {
	Name string
	Age  int
}

func main() {
	pool := sync.Pool{
		New: func() interface{} {
			return &Student{
				Name: "张三",
				Age:  18,
			}
		},
	}

	st := pool.Get().(*Student)
	println(st.Name, st.Age)
	fmt.Printf("st addr = %p\n", st)

	// 修改对象状态
	st.Name = "李四"
	st.Age = 20

	// 在放回池中之前重置对象状态
	resetStudent(st)

	pool.Put(st)

	st2 := pool.Get().(*Student)
	println(st2.Name, st2.Age)
	fmt.Printf("st2 addr = %p\n", st2)
}

// resetStudent 用于重置 Student 对象的状态
func resetStudent(s *Student) {
	s.Name = "张三"
	s.Age = 18
}

sync.Pool使用场景

sync.Pool通过复用对象来降低gc带来的性能损耗，高并发场景下，每个Goroutine都可能频繁创建一些大对象，造成gc压力很大。所以在高并发场景下出现gc问题时，可以使用sync.Pool减少gc负担。

sync.Pool不能存储带状态的对象，比如Socket连接、数据库连接，因为池中的对象随时可能被gc回收释放；sync.Pool不适合控制缓存对象个数的场景，因为sync.Pool中的对象个数是随机变化的，池中的对象随时有可能被gc的，释放时机是随机的。

沉着冷静2024
关注
专栏目录
golang sync锁详解
qq_35257153的博客
03-30 200
golang sync 互斥锁
golang sync pool
iUcool的博客
04-25 966
sync.Pool是内置对象池技术，可用于缓存临时对象，避免因频繁建立临时对象所带来的消耗以及对GC造成的压力在很多知名框架中都可以看到sync.Pool的大量使用。比如Gin中用sync.Pool来复用每个请求都会创建的对象但是值得注意的是sync.Pool缓存的对象可能被无通知的清理。
Golang sync.Pool
云满笔记
08-03 727
pool 在掌握基础用法的同时, 需要知道 Get 和 Push 方法的实现逻辑, 其中最重要的一点, 是需要将 pool 和 GMP 的调度原理结合起来, 其中两者的 P 的原理其实是一样的, 只是对于资源抢占这一块, GMP 抢占的是 G, pool 抢占的是 pool 数据, 对于这块, 其实是自己个人的理解, 如果理解的不对, 还请大家帮忙指出。...
Golang sync.Once
云满笔记
08-03 221
不过, 单凭这样一个判断的保证是不够的, 因为, 如果有两个 goroutine 都调用了同一个新的 Once 值的 Do 方法, 并且几乎同时执行到了其中的这个条件判断代码, 那么它们就都会因判断结果为 false, 而继续执行 Do 方法中剩余的代码。由于进入临界区之前, 肯定要锁定保护它的互斥锁 m, 显然会降低代码的执行速度, 所以其中的第二次条件判断, 以及后续的操作就被称为"慢路径"或者"常规路径"。当一个函数不希望程序在一开始的时候就被执行的时候, 我们可以使用 sync.Once。...
Golang sync.Once详解
neweastsun的专栏
10-27 1869
通过源码可以理解Once的原理，同时也了解Mutex和atomic的具体应用示例。
golang sync.map的使用
crontab_e的博客
04-19 216
【代码】golang sync.map的使用。
Golang sync.WaitGroup
云满笔记
08-02 1816
WaitGroup 是开箱即用和并发安全的, 可以通过它很方便地实现一对多 goroutine 协作流程, 即: 一个分发子任务的 goroutine, 和多个执行子任务的 goroutine, 共同来完成一个较大的任务。在使用 WaitGroup 值的时候, 我们一定要注意, 千万不要让其中的计数器的值小于 0, 否则就会引发 panic。...
golang sync.Map
qq_40977791的博客
11-23 444
线程安全 golang mutex
golang sync.mutex
weixin_41479678的博客
05-24 883
文章目录互斥锁读写锁 互斥锁 mutex的底层是通过atmoic原子操作来lock和unlock lock（）和unlock（）通过对资源枷锁解锁来避免争抢，同一时刻只能有一个goroutine对资源进行操作，等待的goroutine通过自旋和等待队列老获得锁 读写锁 当读的协程远远大于写的协程数，采用互斥锁不免影响性能，此时可采用读写锁 有1000次的读和10次的写操作，在互斥锁的情况下的耗时1.4s 将读的锁换成读写锁 耗时是毫秒级的，以上很好的说明读多于写的场景，读写锁与互斥锁的性能差
Golang sync.Mutex分析
qq_45463438的博客
06-25 559
sync.Mutex是一个不可重入的排他锁。当一个 goroutine 获得了这个锁的拥有权后， 其它请求锁的 goroutine 就会阻塞在 Lock 方法的调用上，直到锁被释放。
【Go】Golang Sync包
藏经阁 | 玄苦
05-30 3977
一. 前言 Golang sync包提供了基础的异步操作方法，包括互斥锁Mutex，执行一次Once和并发等待组WaitGroup。 本文主要介绍sync包提供的这些功能的基本使用方法。 Mutex: 互斥锁 RWMutex：读写锁 WaitGroup：并发等待组 Once：执行一次 Cond：信号量 Pool：临时对象池 Map：自带锁的map 二. sync.Mutex sync.Mute...
5000字带你精通golang sync包的所有姿势
bactcolor的博客
07-08 200
golang并发编程中sync包提供了一些高性能的同步原语，可以帮助我们更好地管理并发状态和资源。在平时的编码过程中，要注意sync不同的使用场景，不可为了使用而使用，当然，装逼除外。
Golang Sync.WaitGroup 使用及原理
weixin_44046117的博客
02-22 498
Golang Sync.WaitGroup 使用及原理 使用 func main() { var wg sync.WaitGroup for i := 0; i < 10; i++ { wg.Add(1) go func() { defer wg.Done() fmt.Println("Hello WaitGroup!") }() } wg.Wait() } 实现 首先看 waitgroup 到底是什么数据结构 type WaitGroup struct { noC
golang sync锁
wt_dd的博客
03-30 104
golang sync 锁
【Go】-Context库的使用
knoci的博客
09-13 810
当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准。取消此上下文将释放与其相关的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel，通常用于数据库或者网络连接的超时控制。用来处理一个请求的 goroutine 通常需要访问一些与请求特定的数据，比如终端用户的身份认证信息、验证相关的token、请求的截止时间。取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。
Golang | Leetcode Golang题解之第409题最长回文串
最新发布
weixin_66442839的博客
09-16 388
Golang | Leetcode Golang题解之第409题最长回文串
go语言的基本语法
Au_ust的博客
09-16 660
不加defer应为1111111222222233333334444444加了之后为1111111333333344444442222222因为defer置后了两个函数的调用，采用栈的结构打印先被defer的语句后执行，后被defer的语句先执行（后进先出）defer函数:在return之前，所有的defer函数会执行完毕当执行外围函数中的return语句时，只有其中所有的延迟函数都执行完毕后外围函数才会真正返回。
Go语言错误处理之道：优雅地应对程序中的问题
王中阳的博客
09-13 512
错误处理是Go语言编程中的一个重要概念。通过返回错误、检查错误、使用defer进行资源清理、包装和传播错误，Go开发者可以编写出健壮且可靠的代码。对于初学者来说，养成良好的错误处理习惯将有助于你成长为一名更专业的程序员。
学习笔记-Golang中的Context
weixin_60214397的博客
09-14 1445
通过context实现对golang中goroutine的控制
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值