Go语言教程：使用读写锁实现并发安全的计数器

在本教程中，我们将通过一个简单的计数器示例，学习如何使用Go语言中的读写锁（sync.RWMutex）来实现并发安全的操作。我们将详细解释代码的每一部分，并提供一些额外的示例来帮助你更好地理解。

代码结构#

首先，让我们看一下完整的代码：

1
package main
2

3
import (
4
  "log"
5
  "sync"
6
  "time"
7
)
8

9
// counter 代表计数器。
10
type counter struct {
11
  num uint         // 计数。
12
  mu  sync.RWMutex // 读写锁。
13
}
14

15
// number 会返回当前的计数。
16
func (c *counter) number() uint {
17
  c.mu.RLock()
18
  defer c.mu.RUnlock()
19
  return c.num
20
}
21

22
// add 会增加计数器的值，并会返回增加后的计数。
23
func (c *counter) add(increment uint) uint {
24
  c.mu.Lock()
25
  defer c.mu.Unlock()
26
  c.num += increment
27
  return c.num
28
}
29

30
func main() {
31
  c := counter{}
32
  count(&c)
33
  redundantUnlock()
34
}
35

36
func count(c *counter) {
37
  // sign 用于传递演示完成的信号。
38
  sign := make(chan struct{}, 3)
39
  go func() { // 用于增加计数。
40
    defer func() {
41
      sign <- struct{}{}
42
    }()
43
    for i := 1; i <= 10; i++ {
44
      time.Sleep(time.Millisecond * 500)
45
      c.add(1)
46
    }
47
  }()
48
  go func() {
49
    defer func() {
50
      sign <- struct{}{}
51
    }()
52
    for j := 1; j <= 20; j++ {
53
      time.Sleep(time.Millisecond * 200)
54
      log.Printf("The number in counter: %d [%d-%d]",
55
        c.number(), 1, j)
56
    }
57
  }()
58
  go func() {
59
    defer func() {
60
      sign <- struct{}{}
61
    }()
62
    for k := 1; k <= 20; k++ {
63
      time.Sleep(time.Millisecond * 300)
64
      log.Printf("The number in counter: %d [%d-%d]",
65
        c.number(), 2, k)
66
    }
67
  }()
68
  <-sign
69
  <-sign
70
  <-sign
71
}
72

73
func redundantUnlock() {
74
  var rwMu sync.RWMutex
75

76
  // 示例1。
77
  //rwMu.Unlock() // 这里会引发panic。
78

79
  // 示例2。
80
  //rwMu.RUnlock() // 这里会引发panic。
81

82
  // 示例3。
83
  rwMu.RLock()
84
  //rwMu.Unlock() // 这里会引发panic。
85
  rwMu.RUnlock()
86

87
  // 示例4。
88
  rwMu.Lock()
89
  //rwMu.RUnlock() // 这里会引发panic。
90
  rwMu.Unlock()
91
}

代码解析#

1. 定义计数器结构体#

1
type counter struct {
2
  num uint         // 计数。
3
  mu  sync.RWMutex // 读写锁。
4
}

counter结构体包含一个无符号整数num用于存储计数值，以及一个读写锁mu用于保护对num的并发访问。

2. 获取当前计数值的方法#

1
func (c *counter) number() uint {
2
  c.mu.RLock()
3
  defer c.mu.RUnlock()
4
  return c.num
5
}

number方法使用读锁（RLock）来保护对num的读取操作，并在读取完成后释放读锁（RUnlock）。

3. 增加计数值的方法#

1
func (c *counter) add(increment uint) uint {
2
  c.mu.Lock()
3
  defer c.mu.Unlock()
4
  c.num += increment
5
  return c.num
6
}

add方法使用写锁（Lock）来保护对num的写操作，并在写入完成后释放写锁（Unlock）。

4. 主函数#

1
func main() {
2
  c := counter{}
3
  count(&c)
4
  redundantUnlock()
5
}

在main函数中，我们创建一个counter实例，并调用count函数和redundantUnlock函数。

5. 并发计数函数#

1
func count(c *counter) {
2
  // sign 用于传递演示完成的信号。
3
  sign := make(chan struct{}, 3)
4
  go func() { // 用于增加计数。
5
    defer func() {
6
      sign <- struct{}{}
7
    }()
8
    for i := 1; i <= 10; i++ {
9
      time.Sleep(time.Millisecond * 500)
10
      c.add(1)
11
    }
12
  }()
13
  go func() {
14
    defer func() {
15
      sign <- struct{}{}
16
    }()
17
    for j := 1; j <= 20; j++ {
18
      time.Sleep(time.Millisecond * 200)
19
      log.Printf("The number in counter: %d [%d-%d]",
20
        c.number(), 1, j)
21
    }
22
  }()
23
  go func() {
24
    defer func() {
25
      sign <- struct{}{}
26
    }()
27
    for k := 1; k <= 20; k++ {
28
      time.Sleep(time.Millisecond * 300)
29
      log.Printf("The number in counter: %d [%d-%d]",
30
        c.number(), 2, k)
31
    }
32
  }()
33
  <-sign
34
  <-sign
35
  <-sign
36
}

count函数启动了三个并发的goroutine：

第一个goroutine每500毫秒增加一次计数。
第二个和第三个goroutine分别每200毫秒和300毫秒读取并打印当前计数值。

sign通道用于等待所有goroutine完成。

6. 错误解锁示例#

1
func redundantUnlock() {
2
  var rwMu sync.RWMutex
3

4
  // 示例1。
5
  //rwMu.Unlock() // 这里会引发panic。
6

7
  // 示例2。
8
  //rwMu.RUnlock() // 这里会引发panic。
9

10
  // 示例3。
11
  rwMu.RLock()
12
  //rwMu.Unlock() // 这里会引发panic。
13
  rwMu.RUnlock()
14

15
  // 示例4。
16
  rwMu.Lock()
17
  //rwMu.RUnlock() // 这里会引发panic。
18
  rwMu.Unlock()
19
}

redundantUnlock函数展示了几种错误使用读写锁的方法，这些错误会导致程序崩溃（panic）。正确的使用方式是成对调用RLock/RUnlock和Lock/Unlock。

总结#

通过这个示例，我们学习了如何使用Go语言中的读写锁来实现并发安全的计数器。我们还展示了几种错误使用锁的方法，以帮助你避免常见的陷阱。