Go语言教程：并发编程

示例1：使用通道（Channel）进行并发控制#

代码解析#

1
package main
2

3
import (
4
  "fmt"
5
  //"time"
6
)
7

8
func main() {
9
  num := 10
10
  sign := make(chan struct{}, num)
11

12
  for i := 0; i < num; i++ {
13
    go func() {
14
      fmt.Println(i)
15
      sign <- struct{}{}
16
    }()
17
  }
18

19
  // 办法1。
20
  //time.Sleep(time.Millisecond * 500)
21

22
  // 办法2。
23
  for j := 0; j < num; j++ {
24
    <-sign
25
  }
26
}

代码讲解#

1. 通道的创建：

   1
   sign := make(chan struct{}, num)
   

   这里我们创建了一个缓冲通道sign，缓冲大小为num（10）。通道用于在goroutine之间传递信号。

2. 启动多个goroutine：

   1
   for i := 0; i < num; i++ {
   2
       go func() {
   3
           fmt.Println(i)
   4
           sign <- struct{}{}
   5
       }()
   6
   }
   

   我们启动了num个goroutine，每个goroutine都会打印变量i的值，并向通道sign发送一个空结构体struct{}作为信号。

3. 等待所有goroutine完成：

   1
   for j := 0; j < num; j++ {
   2
       <-sign
   3
   }
   

   通过从通道sign接收信号，我们确保所有goroutine都已经完成。

举一反三#

• 通道的缓冲区：可以根据需要调整通道的缓冲区大小，以控制并发的数量。
• 通道的类型：可以使用不同类型的通道来传递不同类型的数据。

示例2：使用原子操作进行并发控制#

代码解析#

1
package main
2

3
import (
4
  "fmt"
5
  "sync/atomic"
6
  "time"
7
)
8

9
func main() {
10
  var count uint32
11
  trigger := func(i uint32, fn func()) {
12
    for {
13
      if n := atomic.LoadUint32(&count); n == i {
14
        fn()
15
        atomic.AddUint32(&count, 1)
16
        break
17
      }
18
      time.Sleep(time.Nanosecond)
19
    }
20
  }
21
  for i := uint32(0); i < 10; i++ {
22
    go func(i uint32) {
23
      fn := func() {
24
        fmt.Println(i)
25
      }
26
      trigger(i, fn)
27
    }(i)
28
  }
29
  trigger(10, func() {})
30
}

代码讲解#

1. 原子变量的使用：

   1
   var count uint32
   

   我们使用一个无符号32位整数count作为计数器，通过原子操作来保证并发安全。

2. 触发函数**trigger**：

   1
   trigger := func(i uint32, fn func()) {
   2
       for {
   3
           if n := atomic.LoadUint32(&count); n == i {
   4
               fn()
   5
               atomic.AddUint32(&count, 1)
   6
               break
   7
           }
   8
           time.Sleep(time.Nanosecond)
   9
       }
   10
   }
   

   触发函数trigger会不断检查count的值是否等于i，如果相等则执行传入的函数fn，并将count加1。

3. 启动多个goroutine：

   1
   for i := uint32(0); i < 10; i++ {
   2
       go func(i uint32) {
   3
           fn := func() {
   4
               fmt.Println(i)
   5
           }
   6
           trigger(i, fn)
   7
       }(i)
   8
   }
   

   我们启动了10个goroutine，每个goroutine都会调用trigger函数，确保按顺序打印i的值。

4. 等待所有goroutine完成：

   1
   trigger(10, func() {})
   

   最后，我们调用trigger(10, func() {})来等待所有goroutine完成。

拓展#

• 原子操作：可以使用sync/atomic包中的其他原子操作函数，如atomic.StoreUint32、atomic.CompareAndSwapUint32等。
• 触发条件：可以根据需要修改触发条件，以实现不同的并发控制逻辑。

总结#

通过这两个示例，我们学习了如何使用通道和原子操作来进行并发控制。通道适用于需要在goroutine之间传递信号或数据的场景，而原子操作则适用于需要高效、低延迟的并发控制场景。