15_GoLang语言入门_基础语法_并发与多线程04_WaitGroup和互斥锁

字数统计: 1.6k字   |   阅读时长≈ 7分

1、同步/异步：

** 同步：sync**

one by one 一个接一个，串行

异步：async

并行，同时执行

异步任务：

同时执行，“并发”。

2、WaitGroup: 同步等待组

执行了wait的goroutine，要等待同步等待组中其他的goroutine执行完毕。

  • 内置计数器：

    • 初始值为：counter:0
    • 要执行的goroutine的数量

  • **Add(3), **设置计数器的数量, 设置counter的值

  • ** Done(), **将内置的计数器的数值减1。同add(-1) counter的值-1

  • **Wait(), **等待，导致执行wait的goroutine进入阻塞状态。同步等待组中的计数器的值为0，解除阻塞。

Add(3),三个goroutine要执行

…

子goroutine：函数，最后一行Done() 计数器减1

wait() 主程序等待

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	wg.Add(2) //等待n个执行完毕
	go printNum1(&wg)
	go printNum2(&wg)
	wg.Wait() //主程序main函数中执行了Wait(),进入阻塞状态。底层计数器为0，解除阻塞。
	fmt.Println("main...over...")
}
func printNum1(wg *sync.WaitGroup) { //值类型传递地址，不用副本拷贝
	rand.Seed(time.Now().UnixNano())
	for i := 1; i <= 100; i++ {
		fmt.Println("子goroutine1中，i:", i)
		//time.Sleep(time.Duration(rand.Intn(1000)))
	}
	wg.Done()
}

func printNum2(wg *sync.WaitGroup) {
	for j := 1; j <= 100; j++ {
		fmt.Println("\t子goroutine2中，j:", j)
		//time.Sleep(time.Duration(rand.Intn(1000)))
	}
	wg.Done()
}

3、互斥锁：

  • ** 并发读取全局数据时,会出问题，利用”锁”解决问题。**

开 / 关，”上厕所”的例子

  • 锁头对象 （struct）
  • 互斥：锁定—解锁
    • 有两个指针方法
      • Lock(),上锁
        • 阻塞的：只能有一个goroutine上锁，其他的goroutine处于阻塞状态。
      • Unlock(),开锁

3.1、可能存在问题的案例：

银行存钱问题，同时进行，在读取完后，未来得及写入的情况下，又进行了读取… … ****

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main
import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)
var ticks int = 1000                               //存在共享数据，同时子go程存在读完之后，同时写，出现混乱... ...
var _wg sync.WaitGroup
func main() {
	/*
		售票：四个窗口一块售出100张票
	*/
	_wg.Add(4)
	go saleTicks("售票厅1")
	go saleTicks("售票厅2")
	go saleTicks("售票厅3")
	go saleTicks("售票厅4")
	_wg.Wait()
	fmt.Println("main...over...")
}
func saleTicks(name string) {
	rand.Seed(time.Now().UnixNano())
	for {
		if ticks > 0 {
			time.Sleep(time.Duration(rand.Intn(5000)))
			fmt.Println(name, ":", ticks)
			ticks--
		} else {
			fmt.Println(name, "结束买票了！！！")
			break
		}
	}
	_wg.Done()
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
售票厅4 : 49
售票厅3 : 49
售票厅1 : 47
售票厅2 : 49
售票厅4 : 46
售票厅3 : 46
售票厅2 : 43
售票厅4 : 42
售票厅1 : 43
售票厅3 : 41
售票厅2 : 40
售票厅4 : 38
售票厅3 : 37
售票厅2 : 37
售票厅4 : 35
售票厅1 : 37
售票厅2 : 33
售票厅3 : 34
售票厅1 : 32
售票厅2 : 31
售票厅4 : 29
售票厅3 : 29
售票厅1 : 29
售票厅3 : 26
售票厅4 : 26
售票厅1 : 24
售票厅1 : 23
售票厅2 : 27
售票厅4 : 22
售票厅1 : 21
售票厅3 : 22
售票厅2 : 18
售票厅3 : 17
售票厅1 : 17
售票厅2 : 16
售票厅4 : 15
售票厅3 : 14
售票厅1 : 12
售票厅2 : 12
售票厅3 : 10
售票厅4 : 10
售票厅1 : 9
售票厅4 : 7
售票厅2 : 6
售票厅1 : 5
售票厅3 : 4
售票厅1 : 4
售票厅2 : 3
售票厅1 : 1
售票厅4 : 3
售票厅2 : -1
售票厅1 结束买票了！！！
售票厅3 : -2
售票厅3 结束买票了！！！
售票厅2 结束买票了！！！
售票厅4 结束买票了！！！
main...over...

3.2、****互斥锁：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	var mutex sync.Mutex
	fmt.Println("main,即将锁定mutex")
	mutex.Lock() //锁定产生互斥
	fmt.Println("main已经锁定mutex")
	
	for i := 1; i <= 3; i++ {
		go func(j int) {
			fmt.Println("子goroutine", j, "即将锁定mutex")
			mutex.Lock() //阻塞
			fmt.Println("子goroutine", j, "已经锁定！！！")
		}(i)
	}
	
	
	time.Sleep(3 * time.Second)
	fmt.Println("main,即将解锁mutex")
	mutex.Unlock()
	fmt.Println("main,已经解锁mutex")
	//mutex.Unlock()//报错了！unlock of unlocked mutex
	//fmt.Println("main,想再解锁mutex")
	time.Sleep(2 * time.Second)
	fmt.Println("main...over...")
}

结果：

1
2
3
4
5
6
7
8
9
10
main,即将锁定mutex              
main已经锁定mutex                 
  子goroutine 3 即将锁定mutex       //Lock（）产生阻塞，执行不了。因为只有一把锁，主go程在使用，需要主go程解锁后，三个子go程争抢，谁可以继续锁定执行下面的内容！
  子goroutine 1 即将锁定mutex
  子goroutine 2 即将锁定mutex

main,即将解锁mutex
main,已经解锁mutex
子goroutine 3 已经锁定！！！
main...over...

3.3、利用互斥锁解决上述问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)
var ticks02 int = 2000
var wg02 sync.WaitGroup
var mutex02 sync.Mutex //创建一个互斥锁
func main() {
	/*
		上了互斥锁之后，one by one执行，执行效率下降，但数据是安全的。
	*/
	/*
		售票：四个窗口一块售出100张票
	*/
	wg02.Add(4)
	go saleTicks02("售票厅1")
	go saleTicks02("售票厅2")
	go saleTicks02("售票厅3")
	go saleTicks02("售票厅4")
	wg02.Wait()
	fmt.Println("main...over...")
}
func saleTicks02(name string) {
	rand.Seed(time.Now().UnixNano())
	for {
		mutex02.Lock()
		if ticks02 > 0 {
			time.Sleep(time.Duration(rand.Intn(5000)))
			fmt.Println(name, ":", ticks02)
			ticks02--
		} else {
			fmt.Println(name, "结束买票了！！！")
			mutex02.Unlock() //跳出之前，要先解锁
			break
		}
		mutex02.Unlock()
	}
	wg02.Done()
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
售票厅1 : 50
售票厅1 : 49
售票厅1 : 48
售票厅1 : 47
售票厅1 : 46
售票厅1 : 45
售票厅1 : 44
售票厅1 : 43
售票厅1 : 42
售票厅2 : 41
售票厅4 : 40
售票厅4 : 39
售票厅4 : 38
售票厅4 : 37
售票厅4 : 36
售票厅4 : 35
售票厅4 : 34
售票厅4 : 33
售票厅4 : 32
售票厅4 : 31
售票厅4 : 30
售票厅4 : 29
售票厅4 : 28
售票厅4 : 27
售票厅3 : 26
售票厅1 : 25
售票厅1 : 24
售票厅1 : 23
售票厅1 : 22
售票厅1 : 21
售票厅1 : 20
售票厅1 : 19
售票厅1 : 18
售票厅1 : 17
售票厅1 : 16
售票厅1 : 15
售票厅1 : 14
售票厅1 : 13
售票厅1 : 12
售票厅1 : 11
售票厅1 : 10
售票厅1 : 9
售票厅1 : 8
售票厅1 : 7
售票厅1 : 6
售票厅1 : 5
售票厅2 : 4
售票厅4 : 3
售票厅3 : 2
售票厅1 : 1
售票厅1 结束买票了！！！
售票厅2 结束买票了！！！
售票厅4 结束买票了！！！
售票厅3 结束买票了！！！
main...over...

⚠️注意：

** 需要 对c#j进阶课的异步多线程的互斥锁进一步加强！**

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家