16_GoLang语言入门_基础语法_并发与多线程05_读写锁

字数统计: 1.5k字   |   阅读时长≈ 6分

1、读写锁：sync.RWMutex

变量的访问，put(set) / get 读写操作

成对的指针方法：

Lock(), 写锁定

** Unlock(), 写解锁**

**
**

** RLock(), 读锁定**

** RUnlock(), 读解锁**

  • 读写锁的使用中锁定规则:
    • 写操作都是互斥的。
    • 读和写是互斥的。
    • 读和读不互斥。 //读基本不存在不安全性

理解为：

可以多个goroutine同时读取数据，

但是写只允许一个goroutine写数据。

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 rwm sync.RWMutex
	for i := 1; i <= 3; i++ {
		go func(j int) {
			fmt.Printf("goroutine %d,-----尝试读锁定...\n", j)
			rwm.RLock()
			fmt.Printf("goroutine %d,-----已经读锁定了...\n", j)
			time.Sleep(5 * time.Second)
			fmt.Printf("\tgoroutine %d,尝试读解锁...\n", j)
			rwm.RUnlock()
			
		}(i)
	}
	time.Sleep(2 * time.Second)
	fmt.Println("main尝试写锁定...")
	rwm.Lock()
	fmt.Println("main已经写锁定了...")
	fmt.Println("111111")
	fmt.Println("222222")
	rwm.Unlock()
	fmt.Println("main已经写解锁了...")
}

结果：读和读锁不互斥，读写锁****互斥

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
goroutine 2,-----尝试读锁定...
goroutine 1,-----尝试读锁定...
goroutine 3,-----尝试读锁定...
        goroutine 3,-----已经读锁定了...
        goroutine 2,-----已经读锁定了...
        goroutine 1,-----已经读锁定了...
main尝试写锁定...
        goroutine 1,尝试读解锁...
                goroutine 1,已经读解锁...
        goroutine 2,尝试读解锁...
                goroutine 2,已经读解锁...
        goroutine 3,尝试读解锁...
                goroutine 3,已经读解锁...
main已经写锁定了...
111111
222222
main已经写解锁了...

结果：读和读锁不互斥，读写锁互斥

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
goroutine 1,-----尝试读锁定...
        goroutine 1,-----已经读锁定了...
goroutine 2,-----尝试读锁定...
        goroutine 2,-----已经读锁定了...
goroutine 3,-----尝试读锁定...
        goroutine 3,-----已经读锁定了...//三个读锁不互斥
main尝试写锁定...                        //写锁要执行，需要等待读锁全部解除
                goroutine 3,尝试读解锁...
                        oroutine 3,已经读解锁...
                goroutine 2,尝试读解锁...
                        oroutine 2,已经读解锁...
                goroutine 1,尝试读解锁...
                        oroutine 1,已经读解锁...
main已经写锁定了...
111111
222222
main已经写解锁了...

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
31
32
33
34
35
36
37
38
39
40
41
42
43
package main
import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)
var n int
var wg001 sync.WaitGroup
var rwm001 sync.RWMutex

func main() {
	wg001.Add(10)
	
	for i := 1; i <= 5; i++ {
		//read
		go func(k int) {
			defer wg001.Done()
			rwm001.RLock() //通过读锁定，来防止别人来写
			fmt.Println("读操作...", k, "即将读取数据...")
			v := n
			fmt.Println("读操作", k, "读取了数据...", n, v)
			rwm001.RUnlock()                                          //先解锁再关闭
			
		}(i)
	}

	for i := 6; i <= 10; i++ {
		//write
		go func(j int) {
			defer wg001.Done()
			rand.Seed(time.Now().UnixNano())
			rwm001.Lock()
			fmt.Println("写操作", j, "即将写入数据...")
			randNum := rand.Intn(100) + 1 //[1,100]
			n = randNum
			fmt.Println("写操作", j, "已经结束，写入了", randNum, n)
			rwm001.Unlock()
		}(i)
	}

	wg001.Wait()
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
      读操作... 2 即将读取数据...
      读操作 2 读取了数据... 0 0
写操作 10 即将写入数据...
写操作 10 已经结束，写入了 44 44
      读操作... 3 即将读取数据...
      读操作 3 读取了数据... 44 44
      读操作... 1 即将读取数据...
      读操作 1 读取了数据... 44 44
      读操作... 4 即将读取数据...
      读操作 4 读取了数据... 44 44
      读操作... 5 即将读取数据...
      读操作 5 读取了数据... 44 44
写操作 6 即将写入数据...
写操作 6 已经结束，写入了 74 74
写操作 7 即将写入数据...
写操作 7 已经结束，写入了 25 25
写操作 8 即将写入数据...
写操作 8 已经结束，写入了 2 2
写操作 9 即将写入数据...
写操作 9 已经结束，写入了 72 72

3、并发读写Map：

3.1 并发读写map

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"
	"sync"
)

type myMap struct {
	map1 map[int]string
	rwm  sync.RWMutex
}

// 将键值对存入map中

func (m *myMap) Set(k int, v string) {
	m.rwm.Lock()
	m.map1[k] = v
	m.rwm.Unlock()
}

//从map中读取数据

func (m *myMap) Get(k int) string {
	m.rwm.Lock()
	defer m.rwm.Unlock()
	return m.map1[k]
}

func main() {
	fmt.Println("-------------------------------------01.测试-并发读写map------------------------------------------")
	{
		//var rwm99 sync.RWMutex
		//map1 := make(map[int]string)
		//for i := 1; i <= 20; i++ {
		//	go func(j int) {
		//		rwm99.Lock()
		//		map1[j] = fmt.Sprint("数据", j)
		//		rwm99.Unlock()
		//	}(i)
		//}
		//time.Sleep(2 * time.Second)
		//fmt.Println(map1)
	}

结果：

1
2
-------------------------------------01.测试-并发读写map------------------------------------------
map[1:数据1 2:数据2 3:数据3 4:数据4 5:数据5 6:数据6 7:数据7 8:数据8 9:数据9 10:数据10 11:数据11 12:数据12 13:数据13 14:数据14 15:数据15 16:数据16 17:数据17 18:数据18 19:数据19 20:数据20]

3.2 带读写锁的并发读写map

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
package main
import (
	"fmt"
	"sync"
)

type myMap struct {
	map1 map[int]string
	rwm  sync.RWMutex
}

// 将键值对存入map中
func (m *myMap) Set(k int, v string) {
	m.rwm.Lock()
	m.map1[k] = v
	m.rwm.Unlock()
}

//从map中读取数据
func (m *myMap) Get(k int) string {
	m.rwm.Lock()
	defer m.rwm.Unlock()
	return m.map1[k]
}

func main() {
	fmt.Println("-------------------------------------02.测试-带读写锁的并发读写map----------------------------------")
	m1 := make(map[int]string)
	m2 := myMap{
		map1: m1,
		rwm:  sync.RWMutex{},
	}
	var myWg sync.WaitGroup
	myWg.Add(30)
	for i := 1; i <= 30; i++ {                           //map不允许并发写
		go func(j int) {
			m2.Set(j, fmt.Sprintf("数据的值为：%d", j*100))
			myWg.Done()
		}(i)
	}
	myWg.Wait()
	fmt.Println("main,开始读取数据...")
	for i := 1; i <= 20; i++ {
		fmt.Println(m2.Get(i))
	}
	fmt.Println("main...over...")
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
-------------------------------------02.测试-带读写锁的并发读写map----------------------------------
main,开始读取数据...
数据的值为：100
数据的值为：200
数据的值为：300
数据的值为：400
数据的值为：500
数据的值为：600
数据的值为：700
数据的值为：800
数据的值为：900
数据的值为：1000
数据的值为：1100
数据的值为：1200
数据的值为：1300
数据的值为：1400
数据的值为：1500
数据的值为：1600
数据的值为：1700
数据的值为：1800
数据的值为：1900
数据的值为：2000
main...over...
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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

很惭愧

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