GoWeb——用sync包实现并发

「爱情、让人受尽委屈。」 2023-10-12 11:22 48阅读 0赞

#### 目录 ####

*   *  1、竞态
     *  2、互斥锁
     *   *  2.1、什么互斥锁
         *   *  2.1.1、sync.Mutex的定义
             *  2.1.2、sync.Mutex的方法
         *  2.2、互斥锁的使用
     *  3、读写互斥锁
     *   *  3.1、什么是读写互斥锁
         *   *  3.1.1、读写互斥锁的定义
             *  3.1.2、读写互斥锁的方法
         *  3.2、读写互斥锁的使用示例
     *  4、sync.Once结构体
     *   *  4.1、sync.Once结构体的定义
         *  4.2、sync.Once的使用
     *  5、同步等待组sync.WaitGroup
     *   *  5.1、同步等待组sync.WaitGroup简介
         *  5.2、同步等待组sync.WaitGroup的使用示例
     *  6、竞态检测器

### 1、竞态 ###

Go语言以构建高并发容易、性能优异而闻名。但是，伴随着并发的使用，可能发生可怕的数据争用的竞态问题。而一旦遇到竞态问题，由于不知道其什么时候发生，所以将产生难以发现和调试的错误。

下面是一个发生数据竟态的示例：

import "fmt"
    
    func main() {
        
    	fmt.Println(getNumber())
    }
    
    func getNumber() int {
        
    	var i int
    	go func() {
        
    		i = 6
    	}()
    	return i
    }

在上面的示例中，getNumber()函数先声明一个变量i,之后在goroutine中单独对i进行设置。而这时程序也正在从函数中返回i,由于不知道goroutine是否已完成对i值的修改，所以将有两种操作发生：

1.  如果goroutine已完成对i值的修改，则最后返回的i值为6；
2.  如果goroutine未完成对i值的修改，则变量i的值从函数返回，为默认值0。

现在根据这两个操作中的哪一个先完成，输出的结果将是0（默认整数值)或6。这就是为什么将其称为数据竞态：从getNumber()函数返回的值会根据（1)或（2)哪个操作先完成而得名。

为了避免竞态的问题，Go提供了许多解决方案，比如通道阻塞、互斥锁等。

### 2、互斥锁 ###

#### 2.1、什么互斥锁 ####

##### 2.1.1、sync.Mutex的定义 #####

在Go语言中，Sync.Mutex是一个结构体对象，用于实现互斥锁，适用于读写不确定的场景（即读写次数没有明显的区别，并且只允许有一个读或者写的场景)。所以该锁也称为“全局锁”。

sync.Mutex结构体由两个字段state和sema组成。其中，state表示当前互斥锁的状态，而sema用于控制锁状态的信号量。

Mutex结构体的定义如下：

type Mutex struct {
        
    	state int32
    	sema uint32
    }

##### 2.1.2、sync.Mutex的方法 #####

sync.Mutex结构体对象有Lock()、Unlock()两个方法。Lock()方法用于加锁，Unlock()方法用于解锁。

在使用lock()方法加锁后，便不能再次对其进行加锁（如果再次加锁，则会造成死锁问题)。直到利用Unlock(0方法对其解锁后，才能再次加锁。

Mutex结构体的Lock()方法的定义如下：

func (m *Mutex) Lock()

Mutex结构体的Unlock()方法的定义如下：

func (m *Mutex) Unlock()

在用Unlock()方法解锁Mutex时，如果Mutex未加锁，则会导致运行时错误。

Lock()和Unlock()方法的使用注意事项如下：

1.  在一个goroutine获得Mutex后，其他goroutine只能等到这个goroutine释放该Mutex。
2.  在使用Lock()方法加锁后，不能再继续对其加锁，直到利用Unlock()方法对其解锁后才能再加锁。
3.  在Lock()方法之前使用Unlock()方法，会导致panic异常。
4.  已经锁定的Mutex并不与特定的goroutine关联，可以利用一个goroutine对其加锁，再利用其他goroutine对其解锁。
5.  在同一个goroutine中的Mutex被解锁之前再次进行加锁，会导致死锁。
6.  该方法适用于读写不确定，并且只有一个读或者写的场景。

#### 2.2、互斥锁的使用 ####

import (
    	"fmt"
    	"sync"
    	"time"
    )
    
    func main() {
        
    	var mutex sync.Mutex
    	wait := sync.WaitGroup{
        }
    	fmt.Println("Locked")
    	mutex.Lock()
    	for i := 1; i <= 5; i++ {
        
    		wait.Add(1)
    		go func(i int) {
        
    			fmt.Println("Not lock:", i)
    			mutex.Lock()
    			fmt.Println("Lock:", i)
    			time.Sleep(time.Second)
    			fmt.Println("Unlock:", i)
    			mutex.Unlock()
    			defer wait.Done()
    		}(i)
    	}
    	time.Sleep(time.Second)
    	fmt.Println("Unlocked")
    	mutex.Unlock()
    	wait.Wait()
    }

Locked
    Not lock: 5
    Not lock: 4
    Not lock: 1
    Not lock: 2
    Not lock: 3
    Unlocked
    Lock: 5
    Unlock: 5
    Lock: 4
    Unlock: 4
    Lock: 1
    Unlock: 1
    Lock: 2
    Unlock: 2
    Lock: 3
    Unlock: 3

### 3、读写互斥锁 ###

#### 3.1、什么是读写互斥锁 ####

##### 3.1.1、读写互斥锁的定义 #####

在Go语言中，读写互斥锁(sync.RWMutex)是一个控制goroutine访问的读写锁。该锁可以加多个读锁或者一个写锁，其经常用于读次数远远多于写次数的场景。

RWMutex结构体组合了Mutex结构体，其定义如下：

type RWMutex struct(
    	w Mutex
    	writerSem uint32
    	readerSem uint32
    	readerCount:int32
    	readerWait int32
    }

##### 3.1.2、读写互斥锁的方法 #####

读写互斥锁有如下四个方法来进行读写操作。

1. 写操作的Lock()和Unlock()方法的定义如下：

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

对于写锁，如果在添加写锁之前已经有其他的读锁和写锁，则lock()方法会阻塞，直到该写锁可用。写锁权限高于读锁，有写锁时优先进行写锁定。

2. 读操作的Rlock(0和RUnlock(0方法的定义如下：

func (*RWMutex)Rlock()
    func (*RWMutex)RUnlock()

如果已有写锁，则无法加载读锁。在只有读锁或者没有锁时，才可以加载读锁。读锁可以加载多个，所以适用于“读多写少”的场景。

读写互斥锁在读锁占用的情况下，会阻止写，但不阻止读。即多个goroutine可以同时获取读锁（读锁调用RLock()方法，而写锁调用Lock()方法），会阻止任何其他goroutine（无论读和写)进来，整个锁相当于由该goroutine独占。

Sync.RWMutex用于读锁和写锁分开的情况。

1.  RWMutex是单写的读锁，该锁可以加多个读锁或者一个写锁。
2.  读锁占用的情况下会阻止写，不会阻止读。多个  
    goroutine可以同时获取读锁。
3.  写锁会阻止其他goroutine（无论读和写)进来，整个锁由该：goroutine独占
4.  该锁适用于“读多写少”的场景。

#### 3.2、读写互斥锁的使用示例 ####

import (
    	"fmt"
    	"math/rand"
    	"sync"
    )
    
    var count int
    var rw sync.RWMutex
    
    func main() {
        
    	ch := make(chan struct{
        }, 6)
    	for i := 0; i < 3; i++ {
        
    		go ReadCount(i, ch)
    	}
    	for i := 0; i < 3; i++ {
        
    		go WriteCount(i, ch)
    	}
    	for i := 0; i < 6; i++ {
        
    		<-ch
    	}
    }
    
    func ReadCount(n int, ch chan struct{
        }) {
        
    	rw.RLock()
    	fmt.Printf("goroutine %d 进入读操作...\n", n)
    	v := count
    	fmt.Printf("goroutine %d 读取结束，值为：%d\n", n, v)
    	rw.RUnlock()
    	ch <- struct{
        }{
        }
    }
    
    func WriteCount(n int, ch chan struct{
        }) {
        
    	rw.Lock()
    	fmt.Printf("goroutine %d 进入写操作...\n", n)
    	v := rand.Intn(10)
    	count = v
    	fmt.Printf("goroutine %d 写入结束，新值为：%d\n", n, v)
    	rw.Unlock()
    	ch <- struct{
        }{
        }
    }

goroutine 0 进入读操作...
    goroutine 0 读取结束，值为：0
    goroutine 2 进入写操作...
    goroutine 2 写入结束，新值为：1
    goroutine 1 进入读操作...
    goroutine 1 读取结束，值为：1
    goroutine 2 进入读操作...
    goroutine 2 读取结束，值为：1
    goroutine 0 进入写操作...
    goroutine 0 写入结束，新值为：7
    goroutine 1 进入写操作...
    goroutine 1 写入结束，新值为：7

多个读操作可以同时读一个数据。虽然加了锁，但读都是不受影响的，即“读和写是互斥的，读和读不互斥”。多个读操作同时读一个数据的示例如下。

import (
    	"sync"
    	"time"
    )
    
    var m *sync.RWMutex
    
    func main() {
        
    	m = new(sync.RWMutex)
    	//过个读操作同时读
    	go Readling(1)
    	go Readling(2)
    	time.Sleep(2 * time.Second)
    }
    
    func Readling(i int) {
        
    	println(i, "reading start")
    	m.RLock()
    	println(i, "reading")
    	time.Sleep(1 * time.Second)
    	m.RUnlock()
    	println(i, "reading over")
    }

1 reading start
    1 reading
    2 reading start
    2 reading
    2 reading over
    1 reading over

由于读写互斥，所以在写开始之后，读必须等写进行完才能继续。读写互斥锁的使用示例如下：

import (
    	"sync"
    	"time"
    )
    
    var m *sync.RWMutex
    
    func main() {
        
    	m = new(sync.RWMutex)
    	go Writing(1)
    	go Read(2)
    	go Writing(3)
    	time.Sleep(2 * time.Second)
    }
    
    func Read(i int) {
        
    	println(i, "reading start")
    	m.RLock()
    	println(i, "reading")
    	time.Sleep(1 * time.Second)
    	m.RUnlock()
    	println(i, "reading over")
    }
    
    func Writing(i int) {
        
    	println(i, "writing start")
    	m.Lock()
    	println(i, "writing")
    	time.Sleep(1 * time.Second)
    	m.Unlock()
    	println(i, "writing over")
    }

3 writing start
    3 writing
    2 reading start
    1 writing start
    3 writing over
    2 reading
    2 reading over
    1 writing
    1 writing over

### 4、sync.Once结构体 ###

#### 4.1、sync.Once结构体的定义 ####

在Go语言中，sync.Once是一个结构体，用于解决一次性初始化问题。它的作用与init()函数类似，其作用是使方法只执行一次。

Sync.Once结构体和init()函数也有所不同：init()函数是在文件包首次被加载时才执行，且只执行一次；而sync.Once结构体是在代码运行中有需要时才执行，且只执行一次。

在很多高并发的场景中需要确保某些操作只执行一次，例如只加载一次配置文件、只关闭一次通道等。

sync.Once结构体的定义如下：

type Once struct {
        
    	done uint32
    	m Mutex
    }

Sync.Once结构体内包含一个互斥锁和一个布尔值。互斥锁保证布尔值和数据的安全，布尔值用来记录初始化是否完成。这样就能保证初始化操作时是并发安全的，并且初始化操作也不会被执行多次。

#### 4.2、sync.Once的使用 ####

sync.Once结构体只有一个Do()方法，该方法的定义如下：

func (o *Once)Do(f func())

下面通过sync.Once.Do()方法来演示多个goroutine只执行打印一次的情景。

import (
    	"fmt"
    	"sync"
    )
    
    func main() {
        
    	var once sync.Once
    	onceBody := func() {
        
    		fmt.Println("test only once, 这里只打印一次！")
    	}
    	done := make(chan bool)
    	for i := 0; i < 6; i++ {
        
    		go func() {
        
    			once.Do(onceBody)
    		}()
    	}
    	for i := 0; i < 6; i++ {
        
    		<-done
    	}
    }

接下来通过一个关闭通道的示例来加深理解。可以调用close()方法来关闭通道，但如果关闭一个已经关闭过的通道，则会使程序宕机，因此可以借助sync.Once.Do()方法，来保证通道在运行的过程中只被关闭1次。

在下面的代码中，开启了两个goroutine去执行func2()函数，当func2()函数执行完后，会调用close()方法关闭参数所指的ch2通道。为了防止多个goroutine同时关闭同一个通道而产生错误，可以调用sync.Once.Do()方法来关闭通道，这样就不会产生多次关闭通道而使得程序崩溃的错误。

import (
    	"fmt"
    	"sync"
    )
    
    var wg sync.WaitGroup
    var once sync.Once
    
    func main() {
        
    	ch1 := make(chan int, 10)
    	ch2 := make(chan int, 10)
    	wg.Add(3)
    
    	go func1(ch1)
    	go func2(ch1, ch2)
    	go func2(ch1, ch2)
    
    	wg.Wait()
    	for ret := range ch2 {
        
    		fmt.Println(ret)
    	}
    }
    
    func func1(ch1 chan<- int) {
        
    	defer wg.Done()
    	for i := 0; i < 10; i++ {
        
    		ch1 <- i
    	}
    	close(ch1)
    }
    
    func func2(ch1 <-chan int, ch2 chan<- int) {
        
    	defer wg.Done()
    	for {
        
    		x, ok := <-ch1
    		if !ok {
        
    			break
    		}
    		ch2 <- 2 * x
    	}
    	once.Do(func() {
        
    		close(ch2) //确保某个操作只执行一次
    	})
    }

0
    2
    4
    6
    8
    10
    12
    14
    16
    18

### 5、同步等待组sync.WaitGroup ###

#### 5.1、同步等待组sync.WaitGroup简介 ####

在Go语言中，Sync.WaitGroup是一个结构体对象，用于等待一组线程的结束。在sync.WaitGroup结构体对象中只有3个方法：Add()、Done()、Wait()。

1. Add()方法的定义如下：

func:(*waitGroup)Add()

Add()方法向内部计数器加上delta,delta可以是负数。如果内部计数器变为0，则Wait()方法会将处于阻塞等待的所有goroutine释放。如果计数器小于0，则调用panic()函数。

2. Done()方法的定义如下：

func(wg *WaitGroup)Done()

Done()方法会减少WaitGroup计数器的值，一般在goroutine的最后执行。

3. Wait()方法的定义如下：

func (wg *WaitGroup)Wait()

Wait()方法会阻塞，直到VaitGroup计数器减为0。

4. Add()、Done()、Wait()对比:

在以上3个方法中，Done()方法是Add(-1)方法的别名。简单来说，使用Add()方法添加计数；使用Done()方法减掉一个计数，如果计数不为0，则会阻塞Wait()方法的运行。一个goroutine调用Add()方法来设定应等待的goroutine的数量。每个被等待的goroutine在结束时应调用Done()  
方法。同时，在主goroutine里可以调用Wait()方法阻塞至所有goroutine结束。

#### 5.2、同步等待组sync.WaitGroup的使用示例 ####

import (
    	"fmt"
    	"sync"
    	"time"
    )
    
    func main() {
        
    	var wg sync.WaitGroup
    	wg.Add(1)
    	go func() {
        
    		defer wg.Done()
    		fmt.Println("1 goroutine sleep ...")
    		time.Sleep(2)
    		fmt.Println("1 goroutine exit ...")
    	}()
    
    	wg.Add(1)
    	go func() {
        
    		defer wg.Done()
    		fmt.Println("2 goroutine sleep ...")
    		time.Sleep(4)
    		fmt.Println("2 goroutine exit ...")
    	}()
    
    	fmt.Println("Waiting for all goroutine")
    	wg.Wait()
    	fmt.Println("All goroutines finished!")
    }

Waiting for all goroutine
    1 goroutine sleep ...
    2 goroutine sleep ...
    1 goroutine exit ...
    2 goroutine exit ...
    All goroutines finished!

用sync.WaitGroup实现等待goroutine组结束的示例如下：

import (
    	"fmt"
    	"sync"
    	"time"
    )
    
    func main() {
        
    	testFunc := func(wg *sync.WaitGroup, id int) {
        
    		defer wg.Done()
    		fmt.Printf("%v goroutine start ...\n", id)
    		time.Sleep(2)
    		fmt.Printf("%v goroutine exit ...\n", id)
    	}
    
    	var wg sync.WaitGroup
    	const N = 3
    	wg.Add(N)
    	for i := 0; i < N; i++ {
        
    		go testFunc(&wg, i)
    	}
    
    	fmt.Println("Waiting for all goroutine")
    	wg.Wait()
    	fmt.Println("all goroutines finished!")
    }

Waiting for all goroutine
    2 goroutine start ...
    1 goroutine start ...
    2 goroutine exit ...
    0 goroutine start ...
    0 goroutine exit ...
    1 goroutine exit ...
    all goroutines finished!

### 6、竞态检测器 ###

在实战开发中，尽管会尽可能仔细，但是还会出现并发错误。

Go语言提供了一个精致且易于使用的竞态分析工具一竞态检测器。

使用竞态检测器的方法很简单：把“`-race`”命令行参数加到“`go build`,`go run`,`go test`”命令中即可。形式如下：

go run -race main.go

该方法是在程序运行时进行检测。它会让编译器为应用或测试构建一个修订后的版本。

竞态检测器会检测事件流，找到那些有问题的代码。在使用一个goroutine将数据写入一个变量时，如果在过程中没有任何同步的操作，这时有另一个goroutine也对该变量进行写入操作，则这时就存在对共享变量的并发访问一数据竞态。竞态检测器会检测出所有正在运行的数据竞态。

竞态检测器只能检测到那些在运行时发生的竞态，无法用来保证肯定不会发生竞态。

模拟非法竞态访问数据的示例代码如下：

import "fmt"
    
    func main() {
        
    	c := make(chan bool)
    	m := make(map[string]string)
    	go func() {
        
    		m["a"] = "one" //第一个冲突访问
    		c <- true
    	}()
    	m["b"] = "two" //第二个冲突访问
    	<-c
    	for k, v := range m {
        
    		fmt.Println(k, v)
    	}
    }

b two
    a one

如果通过“go run race.go”命令正常运行以上这段代码，则不会有任何报错。但以上代码实际上存在竞态的问题，如图所示。

![在这里插入图片描述][06215ea800d74519a04a7d4749f2792e.png]

通过以上输出可以发现上面的代码存在一个数据的竞态。建议：

1.  在开发环境中应多运行race命令进行竞态检测；
2.  在项目达到一定阶段后，也可以运行race命令进行竞态检测;

[06215ea800d74519a04a7d4749f2792e.png]: https://img-blog.csdnimg.cn/06215ea800d74519a04a7d4749f2792e.png