Golang互斥锁——读写锁

Golang原生支持并发应用，几乎没有其他语言默认支持如此多的并发实现工具。本文在上文的基础上讲解读写锁。

1. 互斥锁解决什么问题

我们并不希望多个线程或协程同时访问相同内存。在并发应用中，很多不同的线程或协程很有可能同时访问相同内存变量。

互斥锁可以实现避免同时读写问题。当一个线程写内存变量，同时另一个线程并发读相同的内存变量。程序将会报错，因为读取线程可能正在读错误数据，这些数据正在发生变化。互斥锁跟踪在任何给定时间哪个线程可以访问一个变量。

2. 互斥锁示例

请看下面程序：

package main 
 
import ( 
	"fmt" 
) 
 
func main() { 
	m := map[int]int{} 
	go writeLoop(m) 
	go readLoop(m) 
 
	// 阻塞程序，手动结束 
	block := make(chan struct{}) 
	<-block 
} 
 
func writeLoop(m map[int]int) { 
	for { 
		for i := 0; i < 100; i++ { 
			m[i] = i 
		} 
	} 
} 
 
func readLoop(m map[int]int) { 
	for { 
		for k, v := range m { 
			fmt.Println(k, "-", v) 
		} 
	} 
} 
 

程序创建map，然后两个协程同时访问map，一个持续修改map值，同时另一个读取map值并打印。
运行程序，输出如下：

fatal error: concurrent map iteration and map write 

Go认为同时读写map不安全，程序异常结束。

2.1 互斥锁实现

package main 
 
import ( 
	"fmt" 
	"sync" 
) 
 
func main() { 
	m := map[int]int{} 
 
	mux := &sync.Mutex{} 
 
	go writeLoop(m, mux) 
	go readLoop(m, mux) 
 
	// stop program from exiting, must be killed 
	block := make(chan struct{}) 
	<-block 
} 
 
func writeLoop(m map[int]int, mux *sync.Mutex) { 
	for { 
		for i := 0; i < 100; i++ { 
			mux.Lock() 
			m[i] = i 
			mux.Unlock() 
		} 
	} 
} 
 
func readLoop(m map[int]int, mux *sync.Mutex) { 
	for { 
		mux.Lock() 
		for k, v := range m { 
			fmt.Println(k, "-", v) 
		} 
		mux.Unlock() 
	} 
} 

上述代码中增加 sync.Mutex 类型变量 mux。在写循环中，写之前使用Lock()方法加锁，写结束后调用Unlock()方法释放锁。确保没有其他协程在写过程中获得锁,其他协程被阻塞直到写过程结束。

读循环过程中，迭代map之前加锁，结束后释放锁。

2.2 RWMutex ———— 安全实现并发读

Map可以安全地并发访问，但不能并发读/写或写/写。读写锁支持多个读协程同时访问map，但写锁排斥其他协程。

package main 
 
import ( 
	"fmt" 
	"sync" 
) 
 
func main() { 
	m := map[int]int{} 
 
	mux := &sync.RWMutex{} 
 
	go writeLoop(m, mux) 
	go readLoop(m, mux) 
	go readLoop(m, mux) 
	go readLoop(m, mux) 
	go readLoop(m, mux) 
 
	// stop program from exiting, must be killed 
	block := make(chan struct{}) 
	<-block 
} 
 
func writeLoop(m map[int]int, mux *sync.RWMutex) { 
	for { 
		for i := 0; i < 100; i++ { 
			mux.Lock() 
			m[i] = i 
			mux.Unlock() 
		} 
	} 
} 
 
func readLoop(m map[int]int, mux *sync.RWMutex) { 
	for { 
		mux.RLock() 
		for k, v := range m { 
			fmt.Println(k, "-", v) 
		} 
		mux.RUnlock() 
	} 
} 
 

通过使用sync.RWMutex让程序更高效。可以让多个读协程并发访问，同时保证写协程排斥其他协程。

3. 总结

本文通过示例介绍互斥锁，读写互斥锁可以更高效并发读。

本文参考链接：https://blog.csdn.net/neweastsun/article/details/107282509