go线程同步 基础知识学习

go线程同步 基础知识学习

在go语言中经常会遇到并发的问题，当然我们会优先考虑通道；其实，go语言也给出传统的解决方式，Mutex（互斥锁）和RWMutex（读写锁）来处理竞争条件

单线程和多线线程下并发

//Bank 银行
type Bank struct {
	balance int //余额
}

// Deposit 存款
func (b *Bank) Deposit(amount int) {
	b.balance += amount
}

// Balance 查询余额
func (b *Bank) Balance() int {
	return b.balance
}

//单线程 调用
func test1() {
	b := &Bank{}
	b.Deposit(100)
	b.Deposit(100)
	b.Deposit(100)
	fmt.Println(b.Balance())
}

//开启多个协程调用存款，出现并问题
func test2() {
	var wg sync.WaitGroup
	b := &Bank{}
	n := 10000
	wg.Add(n)
	//开启100个协程调用  存款方法
	for i := 0; i <= n; i++ {
		go func() {
			b.Deposit(10)
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(b.Balance()) //97160  正确的结果应该是：100000
}

互斥锁使用:如果有一个协程持有锁，当其他协程尝试获取锁时，这些协程会被阻塞，直到Mutex解锁

// BankV2 银行
type BankV2 struct {
	balance int        //余额
	m       sync.Mutex // 互斥锁
}

func (b *BankV2) Deposit(amount int) {
	b.m.Lock()         //加锁
	defer b.m.Unlock() //解锁
	b.balance += amount
}

// Balance 查询余额
func (b *BankV2) Balance() int {
	return b.balance
}

func test3() {
	var wg sync.WaitGroup
	b := &BankV2{}
	n := 100
	wg.Add(n)
	//开启100个协程调用  存款方法
	for i := 0; i <= n; i++ {
		go func() {
			b.Deposit(10)
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(b.Balance())
}

读写锁使用：适用于读多写少的场景。它规定了当有人在读数据的时候（即读锁占用），不允许其他协程更新这个数据（即写锁会阻塞）；为了保证程序的效率，多个协程读取数据，互不影响不会阻塞，不会像Mutex那样只有一个协程读同一个数据，读锁与写锁互斥，写锁与写锁互斥

• 可以同时申请多个读锁
• 有读锁时申请写锁将阻塞，有写锁申请读锁会阻塞
• 只要有写锁，后续申请读锁和写锁都会将阻塞

// BankV3  银行
type BankV3 struct {
	balance int          //余额
	rWMutex sync.RWMutex // 读写锁，使用场景：读多写少（微博、B站）
}

func (b *BankV3) Deposit(amount int) {
	b.rWMutex.Lock()         //加锁
	defer b.rWMutex.Unlock() //解锁
	b.balance += amount
}

// Balance 查询余额
func (b *BankV3) Balance() (balance int) {
	b.rWMutex.Lock()
	balance = b.balance
	b.rWMutex.Unlock()
	return balance
}

func test4() {
	var wg sync.WaitGroup
	b := &BankV3{}
	n := 100
	wg.Add(n)
	//开启100个协程调用  存款方法
	for i := 0; i <= n; i++ {
		go func() {
			b.Deposit(10)
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(b.Balance())
}

条件变量sync.Cond

Cond 实现了一个条件变量，在Locker的基础上增加的一个消息通知的功能，保存了一个通知列表，用来唤醒一个或所有因等待条件变量而阻塞的Go协程，以此来实现多个go协程的同步

func listen(name string, s []string, c *sync.Cond) {
	c.L.Lock()
	c.Wait()
	fmt.Println(name, "报名：", s)
	c.L.Unlock()
}
func broadcast(event string, c *sync.Cond) {
	time.Sleep(time.Second)
	c.L.Lock()
	fmt.Println(event)
	c.Broadcast()
	c.L.Unlock()
}
func test5() {
	s1 := []string{"第一魂技"}
	s2 := []string{"第2魂技"}
	s3 := []string{"第3魂技"}
	var m sync.Mutex
	//创建一个带锁条件变量，Lock 通常Mutex或者RWMutex
	/**
	Broadcast唤醒所有因等待条件变量c阻塞的goroutine
	Signal 唤醒一个因等待条件变量C阻塞的goroutine
	Wait 等待c.L解锁并挂起goroutine，在稍后执行后，Wait返回锁定c.L，只有当被Broadcast或者signal唤醒，wait才会返回
	*/
	cond := sync.NewCond(&m)
	go listen("我是谁", s1, cond)
	go listen("我在哪里", s2, cond)
	go listen("我要干什么", s3, cond)
	go broadcast("秒杀开始", cond)
}

注意：在调用Signal、Broadcast之前，应该保证目标go协程进入wait阻塞状态