一文搞懂Go语言互斥锁、读写锁【线程安全】

---

前言

单个线程时数据操作的只有一个线程,数据的修改也只有一个线程参与，数据相对来说是安全的,多线程时对数据操作的不止一个线程,所以同时对数据进行修改的时候难免紊乱

---

一、互斥锁是什么？

1.概念

互斥锁是为了并发的安全,在多个goroutine共同工作的时候,对于共享的数据十分不安全
写入时容易因为竞争造成数据不必要的丢失。
互斥锁一般加在共享数据修改的地方。

2.未加锁

	线程不安全,操作的全局变量会计算异常

package main

import (
	"fmt"
	"sync"
)

var x int = 0

var wg sync.WaitGroup

func add() {
	defer wg.Done()
	for i := 0; i < 5000; i++ {
		x++
	}
}
func main() {
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	fmt.Println(x)
}
/*
打印结果：(每次打印不一样,正常的结果应该是10000)
	6051
	5059
	5748
	10000
*/

3.加锁之后

	线程安全,全局变量计算无异常

package main

import (
	"fmt"
	"sync"
)

var x int = 0

var wg sync.WaitGroup

// 创建一个锁对象
var lock sync.Mutex

func add() {
	defer wg.Done()
	for i := 0; i < 5000; i++ {
		//加锁
		lock.Lock()
		x++
		//解锁
		lock.Unlock()
	}
}
func main() {
	wg.Add(2)
	//开启两个线程
	go add()
	go add()
	wg.Wait()
	fmt.Println(x)
}
/*
打印结果：
	全为10000
*/

二、读写锁【效率革命】

1.为什么读写锁效率高

	使用锁的时候，安全与效率往往需要互相转换
	在对数据进行操作的时候,只会进行数据的读与写
	而读与读之间可以同时进行，读与写之间需要保证写的时候不去读
	此时为了提高效率就发明读写锁,在读写锁机制下,安全没有丝毫降低，但效率进行了成倍的提升
	提升的效率在读与写操作次数差异越大时越明显

2.使用方法

代码如下（示例）：

package main

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

var (
	x      = 0
	rwlock sync.RWMutex
	wg     sync.WaitGroup
)

func write() {
	defer wg.Done()
	rwlock.Lock()
	x++
	rwlock.Unlock()
}

func read() {
	wg.Done()
	//开启读锁
	rwlock.RLock()
	fmt.Println(x)
	//释放读锁
	rwlock.RUnlock()
}
func main() {
	start := time.Now()
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go write()
	}
	// time.Sleep(time.Second)
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go read()
	}
	wg.Wait()
	fmt.Println(time.Now().Sub(start))
}

三、sync.once

1.sync.once产生背景：

	在多个goroutine中往往会由于线程不同步造成数据读写的冲突,特别是在进行文件打开对象创建的时候
	可能会造成向关闭的文件写内容，使用未初始化的对象，或者对一个对象进行多次初始化。

2.sync.once机制概述：

	sync.once保证函数内的代码只执行一次
	实现的机制是在once内部有一个标志位,在执行代码的时候执行一次之后标志位将置为1
	后续判断标志位,如果标志位被改为1则无法再进行操纵

3.sync.once注意点：

	sync.Once.Do()传进去的函数参数无参无返
	一个once对象只能执行一次Do方法,向Do方法内传多个不同的函数时只能执行第一个传进去的
	传进去Do方法的函数无参无返,可以用函数闭包把需要的变量传进去

4.使用方法

	一般结合并发使用,旨在对通道或文件只进行一次关闭

func f2(a <-chan int, b chan<- int) {
	for {
		x, ok := <-a
		if !ok {
			break
		}
		fmt.Println(x)
		b <- x * 10
	}
	// 确保b通道只关闭一次
	once.Do(func() {
		close(b)
	})
}

四、atomic原子包操作

	原子包将指定的数据进行安全的加减交换操作
	网上还有一大堆关于原子包的api感兴趣的小伙伴可以自行百度,这里就不细细阐述了

package main

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

var x int64 = 0

var wg sync.WaitGroup

/*
	原子操作是将数据进行打包枷锁,直接通过指定的函数进行相应的操作
	可以使用load读取、store写入、add修改、swap交换。
	// 类似于读取一个变量、对一个变量进行赋值
*/
func addone() {
	// 没有加锁进行并发的话，会产生数据丢失的情况
	defer wg.Done()
	// x++

	// 不用加锁也可以使用的行云流水
	// 第一个参数是进行操作的数据,第二个是增加的步长
	atomic.AddInt64(&x, 1)

}
func csf() {
	// 进行比较相等则将新值替换旧值
	ok := atomic.CompareAndSwapInt64(&x, 100, 200)
	fmt.Println(ok, x)
}

func main() {
	for i := 0; i < 50000; i++ {
		wg.Add(1)
		go addone()
	}
	wg.Wait()
	fmt.Println(x)
	x = 100
	csf()
	fmt.Println(123)
}

---

总结

读写锁区分读者和写者，而互斥锁不区分 互斥锁同一时间只允许一个线程访问该对象，无论读写；读写锁同一时间内只允许一个写者， 但是允许多个读者同时读对象。 联系：读写锁在获取写锁的时候机制类似于互斥锁。

---

---

GO GO GO !