Go语言教程：并发与互斥锁

导入包#

首先，我们需要导入一些必要的包：

1
import (
2
  "bytes"
3
  "flag"
4
  "fmt"
5
  "io"
6
  "io/ioutil"
7
  "log"
8
  "sync"
9
)

• bytes：提供了缓冲区操作。
• flag：用于解析命令行参数。
• fmt：格式化I/O。
• io：基本的I/O接口。
• ioutil：I/O工具函数。
• log：日志记录。
• sync：并发原语，包括互斥锁。

全局变量#

1
var protecting uint

protecting变量用于指示是否使用互斥锁来保护数据写入。值为0表示不使用，值大于0表示使用。

初始化函数#

1
func init() {
2
  flag.UintVar(&protecting, "protecting", 1, "It indicates whether to use a mutex to protect data writing.")
3
}

init函数用于初始化命令行参数protecting，默认值为1。

主函数#

1
func main() {
2
  flag.Parse()
3
  var buffer bytes.Buffer
4

5
  const (
6
    max1 = 5  // 启用的goroutine数量
7
    max2 = 10 // 每个goroutine写入的数据块数量
8
    max3 = 10 // 每个数据块中重复的数字数量
9
  )
10

11
  var mu sync.Mutex
12
  sign := make(chan struct{}, max1)
13

14
  for i := 1; i <= max1; i++ {
15
    go func(id int, writer io.Writer) {
16
      defer func() {
17
        sign <- struct{}{}
18
      }()
19
      for j := 1; j <= max2; j++ {
20
        header := fmt.Sprintf("\\n[id: %d, iteration: %d]", id, j)
21
        data := fmt.Sprintf(" %d", id*j)
22
        if protecting > 0 {
23
          mu.Lock()
24
        }
25
        _, err := writer.Write([]byte(header))
26
        if err != nil {
27
          log.Printf("error: %s [%d]", err, id)
28
        }
29
        for k := 0; k < max3; k++ {
30
          _, err := writer.Write([]byte(data))
31
          if err != nil {
32
            log.Printf("error: %s [%d]", err, id)
33
          }
34
        }
35
        if protecting > 0 {
36
          mu.Unlock()
37
        }
38
      }
39
    }(i, &buffer)
40
  }
41

42
  for i := 0; i < max1; i++ {
43
    <-sign
44
  }
45
  data, err := ioutil.ReadAll(&buffer)
46
  if err != nil {
47
    log.Fatalf("fatal error: %s", err)
48
  }
49
  log.Printf("The contents:\\n%s", data)
50
}

代码详解#

1. 解析命令行参数：

   1
   flag.Parse()
   

2. 定义缓冲区：

   1
   var buffer bytes.Buffer
   

3. 常量定义：

   1
   const (
   2
       max1 = 5  // 启用的goroutine数量
   3
       max2 = 10 // 每个goroutine写入的数据块数量
   4
       max3 = 10 // 每个数据块中重复的数字数量
   5
   )
   

4. 互斥锁和信号通道：

   1
   var mu sync.Mutex
   2
   sign := make(chan struct{}, max1)
   

5. 启动goroutine：

   1
   for i := 1; i <= max1; i++ {
   2
       go func(id int, writer io.Writer) {
   3
           defer func() {
   4
               sign <- struct{}{}
   5
           }()
   6
           for j := 1; j <= max2; j++ {
   7
               header := fmt.Sprintf("\\n[id: %d, iteration: %d]", id, j)
   8
               data := fmt.Sprintf(" %d", id*j)
   9
               if protecting > 0 {
   10
                   mu.Lock()
   11
               }
   12
               _, err := writer.Write([]byte(header))
   13
               if err != nil {
   14
                   log.Printf("error: %s [%d]", err, id)
   15
               }
   16
               for k := 0; k < max3; k++ {
   17
                   _, err := writer.Write([]byte(data))
   18
                   if err != nil {
   19
                       log.Printf("error: %s [%d]", err, id)
   20
                   }
   21
               }
   22
               if protecting > 0 {
   23
                   mu.Unlock()
   24
               }
   25
           }
   26
       }(i, &buffer)
   27
   }
   

6. 等待所有goroutine完成：

   1
   for i := 0; i < max1; i++ {
   2
       <-sign
   3
   }
   

7. 读取并打印缓冲区内容：

   1
   data, err := ioutil.ReadAll(&buffer)
   2
   if err != nil {
   3
       log.Fatalf("fatal error: %s", err)
   4
   }
   5
   log.Printf("The contents:\\n%s", data)