sync包

最新推荐文章于 2024-09-18 18:55:55 发布
最新推荐文章于 2024-09-18 18:55:55 发布
阅读量520 收藏
点赞数
分类专栏： Golang - 常用的标准库 文章标签： go 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GSW_Stephen/article/details/106160046
版权

sync包包含了对低级别内存访问同步最有用的并发原语。

1. WaitGroup

sync.WiteGroup的应用场景是等待一组并发操作完成。sync.WaitGroup拥有一个内部计数器。当计数器等于0时，Wait()方法会立即返回。否则它将阻塞执行Wait()方法的goroutine直到计数器等于0时为止。

要增加计数器，我们必须使用Add(int)方法。要减少它，我们可以使用Done()。

我们可以将sync.WaitGroup视为一个并发-安全的计数器：调用通过传入的整数执行Add方法增加计数器的增量，并调用Done方法对计数器进行递减。Wait阻塞，直到计数器为零。

func main() {
	var wg sync.WaitGroup

	wg.Add(1)  // 表示一个Goroutine开始了
	go func() {
		defer wg.Done()
		fmt.Println("第一个Goroutine执行完成")
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("第二个Goroutine执行完成")
	}()

	wg.Wait()
	fmt.Println("所有Goroutine执行完成")

}

执行结果为：

第二个Goroutine执行完成
第一个Goroutine执行完成
所有Goroutine执行完成

2. Mutex

Mutex是互斥的意思，是保护程序中需要独占访问共享资源的区域的一种方式，我们可以通过使用Mutex对内存进行保护来协调对内存的访问。

package main

import (
	"sync"
	"fmt"
)

var count int

func main() {
	var lock sync.Mutex
	increment := func() {
		lock.Lock()         // 请求对全局变量的独占，使用互斥锁来解决
		defer lock.Unlock() // 完成对全局变量的独占，释放互斥锁
		count ++
		fmt.Println("Increment: ", count)
	}

	decrement := func() {
		lock.Lock()
		defer lock.Unlock()
		count --
		fmt.Println("Decrement: ", count)
	}

	var wg sync.WaitGroup
	for i := 0; i <= 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			increment()
		}()
	}

	for i := 0; i <= 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			decrement()
		}()
	}

	wg.Wait()
	fmt.Println("全部Goroutine都完成")
}

输出结果为：

Increment:  1
Decrement:  0
Increment:  1
Increment:  2
Increment:  3
Decrement:  2
Decrement:  1
Decrement:  0
Decrement:  -1
Decrement:  -2
Increment:  -1
Increment:  0
全部Goroutine都完成

我们经常在defer语句中调用Unlock，这是很常见的习惯，它可以确保即使出现了panic，调用也总是执行。如果不这样做，程序可能会陷入死锁。

3. RWMutex

读写互斥锁在概念上和互斥是一样的：它保护着对内存的访问。读写锁适合于对数据结构的读次数比写次数多得多的情况。 因为, 读模式锁定时可以共享, 以写模式锁住时意味着独占。

在Go语言中，读写锁由结构体类型sync.RWMutex代表。在此类型的方法集合中包含了两对方法，即：

func (*RWMutex) Lock
func (*RWMutex) Unlock

和

func (*RWMutex) RLock
func (*RWMutex) RUnlock

前一对方法的名称和签名与互斥锁的那两个方法完全一致。它们分别代表了对写操作的锁定和解锁。以下简称它们为写锁定和写解锁。而后一对方法则分别表示了对读操作的锁定和解锁。以下简称它们为读锁定和读解锁。

对已被写锁定的读写锁进行写锁定，会造成当前Goroutine的阻塞，直到该读写锁被写解锁。当然，如果有多个Goroutine因此而被阻塞，那么当对应的写解锁被进行之时只会使其中一个Goroutine的运行被恢复。类似的，对一个已被写锁定的读写锁进行读锁定，也会阻塞相应的Goroutine。但不同的是，一旦该读写锁被写解锁，那么所有因欲进行读锁定而被阻塞的Goroutine的运行都会被恢复。另一方面，如果在进行过程中发现当前的读写锁已被读锁定，那么这个写锁定操作将会等待直至所有施加于该读写锁之上的读锁定都被清除。同样的，在有多个写锁定操作为此而等待的情况下，相应的读锁定的全部清除只能让其中的某一个写锁定操作获得进行的机会。

package main

import (
	"sync"
	"math/rand"
	"time"
	"fmt"
)

var count int

var mutex sync.RWMutex

func write(n int) {
	rand.Seed(time.Now().UnixNano()) // 保证每次的结果都是随机的

	mutex.Lock()
	fmt.Printf("写goroutine %d 正在写数据\n", n)
	num := rand.Intn(500)
	count = num
	fmt.Printf("写goroutine %d 写数据结束，写入新值%d\n", n, num)
	mutex.Unlock()

}

func read(n int) {
	mutex.RLock()
	fmt.Printf("读goroutine %d 正在读数据\n", n)
	num := count
	fmt.Printf("读goroutine %d 读取数据结束，读到数据%d\n", n, num)
	mutex.RUnlock()
}

func main() {
	for i := 0; i < 10; i++ {
		go read(i + 1)
	}

	for i := 0; i < 10; i++ {
		go write(i + 1)
	}
	time.Sleep(time.Second * 5)
}

运行结果为：

读goroutine 1 正在读数据
读goroutine 1 读取数据结束，读到数据0
读goroutine 2 正在读数据
读goroutine 2 读取数据结束，读到数据0
读goroutine 6 正在读数据
读goroutine 6 读取数据结束，读到数据0
写goroutine 10 正在写数据
写goroutine 10 写数据结束，写入新值358
读goroutine 10 正在读数据
读goroutine 5 正在读数据
读goroutine 5 读取数据结束，读到数据358
读goroutine 7 正在读数据
读goroutine 7 读取数据结束，读到数据358
读goroutine 9 正在读数据
读goroutine 3 正在读数据
读goroutine 3 读取数据结束，读到数据358
读goroutine 9 读取数据结束，读到数据358
读goroutine 4 正在读数据
读goroutine 4 读取数据结束，读到数据358
读goroutine 10 读取数据结束，读到数据358
写goroutine 5 正在写数据
写goroutine 5 写数据结束，写入新值358
读goroutine 8 正在读数据
读goroutine 8 读取数据结束，读到数据358
写goroutine 8 正在写数据
写goroutine 8 写数据结束，写入新值358
写goroutine 3 正在写数据
写goroutine 3 写数据结束，写入新值290
写goroutine 4 正在写数据
写goroutine 4 写数据结束，写入新值23
写goroutine 6 正在写数据
写goroutine 6 写数据结束，写入新值332
写goroutine 7 正在写数据
写goroutine 7 写数据结束，写入新值117
写goroutine 9 正在写数据
写goroutine 9 写数据结束，写入新值480
写goroutine 1 正在写数据
写goroutine 1 写数据结束，写入新值85
写goroutine 2 正在写数据
写goroutine 2 写数据结束，写入新值162

从上面的运行结果我们可以看到，读操作是可以同时进行的。但是写操作只能一个一个的进行。

4.Cond

Cond实现了一种条件变量，主要用来解决多个读协程等待共享资源变成ready的场景。在使用Cond的时候，需要特别注意下：每个Cond都会关联一个Lock（*sync.Mutex or *sync.RWMutex），当修改条件或者调用Wait方法时，必须加锁。Cond主要有三个函数构成，Broadcast(), Signal(), Wait()。

4.1 broadcast

用来唤醒所有的处于等待状态的协程，如果没有等待的协程，该函数也不会报错。

// Broadcast wakes all goroutines waiting on c.
//
// It is allowed but not required for the caller to hold c.L
// during the call.
func (c *Cond) Broadcast() {
	c.checker.check()
	runtime_notifyListNotifyAll(&c.notify)
}

4.2 signal

通知单个等待状态的协程，让它继续执行，如果此时有多个协程处于等待状态，会从等待列表中取出最开始等待的那个协程，来接收消息。

// Signal wakes one goroutine waiting on c, if there is any.
//
// It is allowed but not required for the caller to hold c.L
// during the call.
func (c *Cond) Signal() {
	c.checker.check()
	runtime_notifyListNotifyOne(&c.notify)
}

4.3 wait

该函数在被调用之后，在没有收到Signal或者Broadcast的通知之前，协程处于阻塞状态。

// Wait atomically unlocks c.L and suspends execution
// of the calling goroutine. After later resuming execution,
// Wait locks c.L before returning. Unlike in other systems,
// Wait cannot return unless awoken by Broadcast or Signal.
//
// Because c.L is not locked when Wait first resumes, the caller
// typically cannot assume that the condition is true when
// Wait returns. Instead, the caller should Wait in a loop:
//
//    c.L.Lock()
//    for !condition() {
//        c.Wait()
//    }
//    ... make use of condition ...
//    c.L.Unlock()
//
func (c *Cond) Wait() {
	c.checker.check()
	t := runtime_notifyListAdd(&c.notify)
	c.L.Unlock()
	runtime_notifyListWait(&c.notify, t)
	c.L.Lock()
}

4.4 例子

package main

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

var locker = new(sync.Mutex)
var cond = sync.NewCond(locker)

func Test(x int) {
	cond.L.Lock()
	fmt.Println("aaa:", x)
	cond.Wait()
	fmt.Println("bbb:", x)
	time.Sleep(time.Second * 1)
	cond.L.Unlock()
}

func main() {
	for i := 0; i < 5; i++ {
		go Test(i)
	}

	fmt.Println("start all")
	time.Sleep(time.Second * 1)  // 使所有Goroutine进入wait状态
	cond.Signal()  // 唤醒单个锁
	time.Sleep(time.Second * 1)
	cond.Signal()
	time.Sleep(time.Second * 1)
	fmt.Println("broadcast")
	cond.Broadcast()  // 唤醒所有锁
	time.Sleep(time.Second * 3)
	fmt.Println("finish all")
}

执行结果为：

aaa: 0
aaa: 2
aaa: 1
aaa: 3
aaa: 4
start all
bbb: 0
bbb: 2
broadcast
bbb: 4
bbb: 1
bbb: 3
finish all

5. Once

sync.Once.Do(f func())是一个挺有趣的东西,能保证once只执行一次，无论你是否更换once.Do(xx)这里的方法,这个sync.Once块只会执行一次。

5.1 实例

package main

import (
	"sync"
	"fmt"
)

var count = 0
var once sync.Once
var wg sync.WaitGroup

func main() {
	increment := func() {
		count ++
	}
	wg.Add(100)
	for i := 0; i < 100; i++ {
		go func() {
			defer wg.Done()
			once.Do(increment)
		}()
	}

	wg.Wait()
	fmt.Println("count is ", count)
}

输出结果为：

count is  1

第二个实例：

package main

import (
	"sync"
	"fmt"
)

var count int

func main() {
	increment := func() { count ++ }
	decrement := func() { count -- }

	var once sync.Once
	once.Do(increment)
	once.Do(decrement)

	fmt.Println("count is ", count)
}

输出结果：

count is  1

这说明sync.Once只计算调用Do方法的次数，而不是多少次唯一的调用Do方法。

来自东印度的人
关注
专栏目录
Go语言并发编程之sync包详解
一个被知识诅咒的人
09-17 561
本文深入探讨了Go语言的并发编程核心——`sync`包，详细介绍了`WaitGroup`、`Mutex`、`RWMutex`、`Cond`、`Once`和`Pool`等原语的使用方法和适用场景。通过丰富的代码示例和深入的解释，帮助读者全面理解这些工具如何在实际开发中提高并发性能和代码质量。
GO语言基础进阶教程：sync包——互斥锁
qfliweimin的博客
07-08 386
官网文档对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 library routines. Higher-level synchronization is better done via channe
GO语言基础进阶教程：sync包——WaitGroup
qfliweimin的博客
07-07 300
官网文档对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 library routines. Higher-level synchronization is better done via channe
golang的sync包浅析
最新发布
Hock2023的博客
09-18 1154
这个类是用来实现go中并发任务同步的。方法名功能计数器+delta计数器-1阻塞直到计数器变为0sync.WaitGroup内部维护着一个计数器，计数器的值可以增加和减少。例如当我们启动了N 个并发任务时，就将计数器值增加N。每个任务完成时通过调用Done()方法将计数器减1。通过调用Wait()来等待并发任务执行完，当计数器值为0时，表示所有并发任务已经完成。,这个语句往往放在将要并发的函数的第一行，来确保这个函数并发进程完成之后计数器会减一wg.Add(1)
Go语言的sync包
qq_44810543的博客
05-21 385
一、Sync包的WaitGroup方法 有时候我们在生硬的使用time.sleep方法，肯定不合适。代码显得不够优雅。而go语言提供了waitGroup方法，使并发任务的同步。 我们先来看一段代码： var wg sync.WaitGroup func hello() { defer wg.Done() fmt.Println("Hello Goroutine!") } func main() { wg.Add(1) go hello() // 启动另外一个goro
sync包~Go进阶
m0_63230155的博客
07-06 264
sync是synchronization同步这个词的缩写，所以也会叫做同步包。这里提供了基本同步的操作，比如互斥锁等等。这里除了Once和WaitGroup类型之外，大多数类型都是供低级库例程使用的。更高级别的同步最好通过channel通道和communication通信来完成。
golang标准库-sync包使用和应用场景
go go go
05-15 1101
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
【Go】Golang Sync包
藏经阁 | 玄苦
05-30 4025
一. 前言 Golang sync包提供了基础的异步操作方法，包括互斥锁Mutex，执行一次Once和并发等待组WaitGroup。 本文主要介绍sync包提供的这些功能的基本使用方法。 Mutex: 互斥锁 RWMutex：读写锁 WaitGroup：并发等待组 Once：执行一次 Cond：信号量 Pool：临时对象池 Map：自带锁的map 二. sync.Mutex sync.Mute...
5000字带你精通golang sync包的所有姿势
bactcolor的博客
07-08 232
golang并发编程中sync包提供了一些高性能的同步原语，可以帮助我们更好地管理并发状态和资源。在平时的编码过程中，要注意sync不同的使用场景，不可为了使用而使用，当然，装逼除外。
logstash-6.4.3.zip 文件sync包含mysql相关包
07-09
议在使用logstash之前先想清楚自己的需求是什么，从哪种数据源同步到哪里，需要经过怎么样的处理。...output到现在(7.1)都没有jdbc的插件，然而你如果想使用output的jdbc插件就需要自己去安装热心人自己写的插件...
【我的架构师之路】- 说一说go中的sync包
qq_25870633的博客
12-26 2598
【转载请标明出处】https://blog.csdn.net/qq_25870633/article/details/83448234 好久没写博客了！这段时间一直忙于赶公链项目。今天就不打算将区块链的文章了，因为。。。我承诺过每个月4篇文章的，然鹅，这个10月过去了，我TM还没写一篇文章。如果写链相关的篇幅太长，太耗时（下个月继续以太坊源码分析吧），算了今天就写一写 go的一些源码分析吧。 ...
go 同步-互斥锁
Claroja
01-01 202
上锁后任意时刻，只能有一个协程（线程）访问该资源,其他协程等待 标准库sync中的Mutex结构体类型表示,sync.Mutex类型只有两个公开的指针方法，Lock和Unlock package main import ( "fmt" "sync" "time" ) var mutex sync.Mutex // 创建一个互斥量,新建的互斥锁状态为0 func printer(st...
Golang并发编程——sync包详解
ChineHe的博客
07-05 1738
​sync 包是 Go 语言标准库中提供的用于处理并发的包。它包含了各种用于同步和控制并发的工具，可以帮助开发者在多个 goroutine 之间安全地共享数据、协调执行顺序以及避免竞态条件等问题。本文详细对包下的各个结构体及其结构体方法进行了讲解，并给出了部分使用示例。
sync 数据同步
qq：489366879
04-27 903
1 什么是rsync  rsync is a file transfer program for Unix systems. rsync uses the "rsync algorithm" which provides a very fast method for bringing remote files into sync. It does this by sending just t
go学习笔记-sync包
qq_43756091的博客
08-21 319
go学习笔记-sync包 sync包提供了基本的同步基元，如互斥锁。除了Once和WaitGroup类型，大部分都是适用于低水平程序线程，高水平的同步使用channel通信更好一些。 本包的类型的值不应被拷贝。 1. Locker接口 type Locker type Locker interface { Lock() Unlock() } Locker接口代表一个可以加锁和解锁的对象。 1.1 Mutex type Mutex type Mutex struct { state i
Go 1.9 之后的sync包
Paddy90的专栏
03-22 748
sync.Map go 1.9之后加入了线程安全的map，sync.Map。 源码中的注释为我们说明了sync.Map，是一个并发的map，恒定时间调用loads、stores、deletes。同时被多个goroutines调用是安全的。 在使用时不允许分享这些属性，它可能导致更坏的性能与更坏的安全性，相比较于使用一个普通的map与读写锁配合使用。 零map是有效的并且是空的。 在使用之...
线程--多生产多消费（Lock）
小乔与你同在
11-08 168
       上一篇文章使用synchronized 方法和语句会发现，本方只能唤醒所有线程，程序性能较低。是因为唤醒的锁对象不具有确定性。因此java就引进了锁Lock的概念。 1 接口Lock        锁是控制多个线程对共享资源进行访问的工具。通常，...
GO 语言 sync包
05-25
Go语言中的sync包提供了基本的同步原语，如互斥锁、读写锁、条件变量等，能够帮助开发者实现并发安全的程序。 常用的sync包中的类型有： - Mutex：互斥锁，一次只能有一个 goroutine 获得锁并访问共享资源。 - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值