由浅到深认识Go语言（22）：Go语言并发编程

在Go语言中，并发编程主要通过goroutine和channel来实现。

1. goroutine

   goroutine 是 Go 语言中并发的核心。它是一种轻量级的线程，

package main
 
import (
    "fmt"
    "time"
)
 
func hello() {
    fmt.Println("Hello world goroutine")
}
 
func main() {
    go hello() // 启动一个goroutine
 
    fmt.Println("main function done")
    time.Sleep(1 * time.Second) // 等待goroutine执行完成
}

2. channel

   channel 是 goroutine 之间通信的一种方式。

package main
 
import (
    "fmt"
    "time"
)
 
func sum(a []int, c chan int) {
    total := 0
    for _, v := range a {
        total += v
    }
    c <- total // 把sum结果发送到channel c
}
 
func main() {
    a := []int{7, 2, 8, -9, 4, 0}
 
    c := make(chan int) // 创建一个channel
    go sum(a[:len(a)/2], c) // 计算a的前半部分的和
    go sum(a[len(a)/2:], c) // 计算a的后半部分的和
 
    x, y := <-c, <-c // 从channel接收计算结果
 
    fmt.Println(x, y, x + y)
    time.Sleep(1 * time.Second)
}

3. select

   select 语句用于处理多个通道的发送和接收操作。

package main
 
import (
    "fmt"
    "time"
)
 
func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}
 
func main() {
    c := make(chan int)
    quit := make(chan int)
 
    go func() {
        time.Sleep(1 * time.Second)
        quit <- 0
    }()
 
    fibonacci(c, quit)
}

4. 并发和并行

   并发 (concurrency) 是指同时处理多个任务，但在任意时刻只有一个任务在执行。

   并行 (parallelism) 是指同时处理多个任务，且多个任务在同时执行。

package main
 
import (
    "fmt"
    "runtime"
    "sync"
    "time"
)
 
var wg sync.WaitGroup
 
func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 在函数退出时执行，相当于计数器减一
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(2 * time.Second)
    fmt.Printf("Worker %d done\n", id)
}
 
func main() {
    runtime.GOMAXPROCS(1) // 设置为1核心，模拟并发
 
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 将等待组计数器加一
        go worker(i, &wg) // 创建新的goroutine执行worker函数
    }
 
    wg.Wait() // 等待所有goroutine完成
}

以上代码展示了如何使用Go语言的并发特性来实现并发操作。通过创建goroutine，我们可以同时处理多个任务，而不需要额外的线