今天这篇笔记我们来学习锁:互斥锁(Mutex) 和 读写锁(RWMutex)

互斥锁(Mutex)

首先我们来看一段代码,没有加锁的情况下,两个goroutine同时修改一个变量,会发生什么

func main() {
	var count int
	increment := func() {
		count++
		fmt.Printf(" Incrementing: %d n", count)
	}

	decrement := func() {
		count--
		fmt.Printf(" Decrementing: %d n", count)
	}

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

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

	arithmetic.Wait()
	fmt.Println("Arithmetic complete.")

}

上面的代码定义了一个increment方法和一个decrement方法,他们都操作count变量, 然后各自启动5个goutinue去调用这两个方法。 结果如下所示

 Decrementing: 1 
 Incrementing: 2 
 Incrementing: 1
 Decrementing: 0
 Decrementing: -1
 Decrementing: -1
 Incrementing: 0
 Decrementing: -2
 Decrementing: -3
 Incrementing: -2
 Incrementing: -1
 Incrementing: 0
Arithmetic complete.

我们可以看到,结果是乱的,第一个decrementing 应该是-1,结果这里输出了1,第三个incrementing应该是3,结果输出是1. 这样的效果肯定不是我们期望的, 当多个goroutine共享一个变量的时候,我们需要加锁,保证一次只有一个goroutine能够拿到锁。如下代码


func main() {
	var count int
	var lock sync.Mutex

	increment := func() {
		lock.Lock()
		defer lock.Unlock()
		count++
		fmt.Printf(" Incrementing: %d n", count)
	}

	decrement := func() {
		lock.Lock()
		defer lock.Unlock()
		count--
		fmt.Printf(" Decrementing: %d n", count)
	}

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

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

	arithmetic.Wait()
	fmt.Println("Arithmetic complete.")

}

我们在方法中加了lock.Lock()和defer lock.Unlock(), 运行的效果如下图

 Incrementing: 1 
 Incrementing: 2 
 Incrementing: 3
 Incrementing: 4
 Incrementing: 5
 Decrementing: 4
 Decrementing: 3
 Decrementing: 2
 Decrementing: 1
 Decrementing: 0
 Decrementing: -1
 Incrementing: 0

这样的结果符合我们的预期, incrementing的时候和上一条比加了1, decrementing的时候和上一条比减少了1,代码改动是有效的,这就是锁的作用, 加锁后保证一次只有一个goroutine访问共享的变量。

读写锁(RWMutex)

什么是读写锁呢? 读写锁允许多个只读操作并行进行,而写操作会完全互斥。 还是使用上面的例子,假如我有个方法只是想读取count的value,并不改变它,那么我们就可以用RWMutex.
我们稍微改变下上面的代码


func main() {
	var count int
	var lock sync.RWMutex

	increment := func() {
		lock.Lock()
		defer lock.Unlock()
		count++
		fmt.Printf(" Incrementing: %d n", count)
	}

	decrement := func() {
		lock.Lock()
		defer lock.Unlock()
		count--
		fmt.Printf(" Decrementing: %d %dn", count, time.Now().Nanosecond())

		time.Sleep(time.Second)
	}

	read := func() {
		lock.RLock()
		defer lock.RUnlock()
		fmt.Printf(" reading: %d  %dn", count, time.Now().Nanosecond())
		time.Sleep(time.Second)
	}

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

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

	for i := 0; i <= 10; i++ {
		arithmetic.Add(1)
		go func() {
			defer arithmetic.Done()
			read()
		}()
	}

	arithmetic.Wait()
	fmt.Println("Arithmetic complete.")

}

两个改动,将Mutex换成RWMutex, 增加了一个read方法,它只读取count变量,它加锁的方法是lock.RLock(), 同时我们故意加了time.Sleep(time.Second),让read方法和decrement方法执行的时候,停顿一下。
执行结果如下所示

Incrementing: 1 
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 reading: 1  177230700
 Incrementing: 2 
 Incrementing: 3 
 Incrementing: 4
 Incrementing: 5
 Decrementing: 4 193430000
 Decrementing: 3 204475300
 Decrementing: 2 213426500
 Decrementing: 1 227715200
 Decrementing: 0 240186800
 Decrementing: -1 255299900
 Incrementing: 0 
Arithmetic complete.

我们可以看到read方法,几个gorountine执行的时间几乎一样,他们都能拿到读锁,不会被阻塞, 而且它拿到了一个准确的当时的value. 而decrement方法,相同的代码,我们使用的是写锁,不同的gorountine会锁住,他们的执行时间会相差。 这就是读写锁。
拿读锁我们还可以用RWMutex.RLocker()来拿到锁对象sync.Locker。
书中还比较了一个RWMutex和Mutex的性能差异,
当Reader数量比较小(<8)时,RWMutex性能稍差
当Reader数量大于8小于65536的时候, RWMutex比Mutex快一倍
当Reader数量大于131072的时候,RWMutex又比Mutex稍慢
作者说RWMutex要比Mutex稍复杂,所以会有这样的结果
作者在书中说:通常建议使用RWMutex,而不是Mutex, 因为它在逻辑上更合理。

内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/dk168/p/16899871.html

你还没有登录,请先登录注册
  • 还没有人评论,欢迎说说您的想法!