Go语言教程：使用条件变量实现信箱模型

在本教程中，我们将通过一个简单的信箱模型来学习Go语言中的条件变量（Condition Variable）和互斥锁（Mutex）。这个模型模拟了一个信箱的发送和接收过程，信箱可以是空的或满的。我们将详细解释代码的每一部分，并举一反三，帮助你更好地理解这些概念。

代码概述#

以下是我们将要分析的Go代码：

1
package main
2

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

9
func main() {
10
  // mailbox 代表信箱。
11
  // 0代表信箱是空的，1代表信箱是满的。
12
  var mailbox uint8
13
  // lock 代表信箱上的锁。
14
  var lock sync.RWMutex
15
  // sendCond 代表专用于发信的条件变量。
16
  sendCond := sync.NewCond(&lock)
17
  // recvCond 代表专用于收信的条件变量。
18
  recvCond := sync.NewCond(lock.RLocker())
19

20
  // sign 用于传递演示完成的信号。
21
  sign := make(chan struct{}, 3)
22
  max := 5
23
  go func(max int) { // 用于发信。
24
    defer func() {
25
      sign <- struct{}{}
26
    }()
27
    for i := 1; i <= max; i++ {
28
      time.Sleep(time.Millisecond * 500)
29
      lock.Lock()
30
      for mailbox == 1 {
31
        sendCond.Wait()
32
      }
33
      log.Printf("sender [%d]: the mailbox is empty.", i)
34
      mailbox = 1
35
      log.Printf("sender [%d]: the letter has been sent.", i)
36
      lock.Unlock()
37
      recvCond.Signal()
38
    }
39
  }(max)
40
  go func(max int) { // 用于收信。
41
    defer func() {
42
      sign <- struct{}{}
43
    }()
44
    for j := 1; j <= max; j++ {
45
      time.Sleep(time.Millisecond * 500)
46
      lock.RLock()
47
      for mailbox == 0 {
48
        recvCond.Wait()
49
      }
50
      log.Printf("receiver [%d]: the mailbox is full.", j)
51
      mailbox = 0
52
      log.Printf("receiver [%d]: the letter has been received.", j)
53
      lock.RUnlock()
54
      sendCond.Signal()
55
    }
56
  }(max)
57

58
  <-sign
59
  <-sign
60
}

代码详解#

1. 变量声明#

1
var mailbox uint8
2
var lock sync.RWMutex
3
sendCond := sync.NewCond(&lock)
4
recvCond := sync.NewCond(lock.RLocker())
5
sign := make(chan struct{}, 3)
6
max := 5

mailbox：表示信箱的状态，0表示空，1表示满。
lock：读写锁，用于保护对mailbox的访问。
sendCond：用于发送信的条件变量。
recvCond：用于接收信的条件变量。
sign：用于传递演示完成的信号。
max：表示发送和接收的最大次数。

2. 发信协程#

1
go func(max int) {
2
  defer func() {
3
    sign <- struct{}{}
4
  }()
5
  for i := 1; i <= max; i++ {
6
    time.Sleep(time.Millisecond * 500)
7
    lock.Lock()
8
    for mailbox == 1 {
9
      sendCond.Wait()
10
    }
11
    log.Printf("sender [%d]: the mailbox is empty.", i)
12
    mailbox = 1
13
    log.Printf("sender [%d]: the letter has been sent.", i)
14
    lock.Unlock()
15
    recvCond.Signal()
16
  }
17
}(max)

使用lock.Lock()加锁，确保对mailbox的访问是线程安全的。
如果mailbox是满的（mailbox == 1），则调用sendCond.Wait()等待。
当信箱为空时，发送信件（将mailbox设为1），并解锁。
使用recvCond.Signal()通知接收协程信箱已满。

3. 收信协程#

1
go func(max int) {
2
  defer func() {
3
    sign <- struct{}{}
4
  }()
5
  for j := 1; j <= max; j++ {
6
    time.Sleep(time.Millisecond * 500)
7
    lock.RLock()
8
    for mailbox == 0 {
9
      recvCond.Wait()
10
    }
11
    log.Printf("receiver [%d]: the mailbox is full.", j)
12
    mailbox = 0
13
    log.Printf("receiver [%d]: the letter has been received.", j)
14
    lock.RUnlock()
15
    sendCond.Signal()
16
  }
17
}(max)

使用lock.RLock()加锁，确保对mailbox的访问是线程安全的。
如果mailbox是空的（mailbox == 0），则调用recvCond.Wait()等待。
当信箱满时，接收信件（将mailbox设为0），并解锁。
使用sendCond.Signal()通知发送协程信箱已空。

4. 等待协程完成#

1
<-sign
2
<-sign

等待两个协程完成。

举一反三#

1. 多个发送者和接收者#

可以扩展代码，使其支持多个发送者和接收者。只需启动多个发送和接收协程，并适当调整条件变量的使用。

2. 使用通道（Channel）#

Go语言中的通道（Channel）可以简化这种生产者-消费者模型。以下是使用通道实现的示例：

1
package main
2

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

8
func main() {
9
  mailbox := make(chan struct{}, 1)
10
  sign := make(chan struct{}, 2)
11
  max := 5
12

13
  go func(max int) {
14
    defer func() {
15
      sign <- struct{}{}
16
    }()
17
    for i := 1; i <= max; i++ {
18
      time.Sleep(time.Millisecond * 500)
19
      mailbox <- struct{}{}
20
      log.Printf("sender [%d]: the letter has been sent.", i)
21
    }
22
  }(max)
23

24
  go func(max int) {
25
    defer func() {
26
      sign <- struct{}{}
27
    }()
28
    for j := 1; j <= max; j++ {
29
      time.Sleep(time.Millisecond * 500)
30
      <-mailbox
31
      log.Printf("receiver [%d]: the letter has been received.", j)
32
    }
33
  }(max)
34

35
  <-sign
36
  <-sign
37
}

总结#

通过这个教程，我们学习了如何使用Go语言中的条件变量和互斥锁来实现一个简单的信箱模型。我们还展示了如何使用通道来简化这种生产者-消费者模型。希望这个教程能帮助你更好地理解Go语言中的并发编程。