Go 中的并发：从基础知识到高级概念

目录

1. 并发简介
2. 并发与并行
3. go 例程：并发的构建块
4. 通道：go 例程之间的通信
5. select 语句：管理多个通道
6. 同步原语
7. 并发模式
8. 上下文包：管理取消和 超时。
9. 最佳实践和常见陷阱**

1.并发简介

并发是同时处理多个任务的能力。在 go 中，并发性是一等公民，内置于该语言的核心设计中。 go 的并发方法基于通信顺序进程（csp），该模型强调进程之间的通信而不是共享内存。

2.并发与并行：

go 例程支持并发，这是独立执行进程的组合。
如果系统有多个 cpu 核心并且 go 运行时安排 go 例程并行运行，则可能会发生并行（同时执行）。

3。 go 例程：
并发的构建块是 go 例程，是由 go 运行时管理的轻量级线程。它是与其他函数或方法同时运行的函数或方法。 go 例程是 go 并发模型的基础。

主要特征：

• 轻量级：go 例程比操作系统线程轻得多。您可以轻松创建数千个 go 例程，而不会显着影响性能。
• 由 go 运行时管理：go 调度程序处理可用操作系统线程之间的 go 例程分配。
• 廉价创建：启动 go 例程就像在函数调用之前使用 go 关键字一样简单。
• 堆栈大小：go 例程从一个小堆栈（大约 2kb）开始，可以根据需要增长和缩小。

创建 go 例程：
要启动 go 例程，只需使用 go 关键字，后跟函数调用：

go functionname()

或者使用匿名函数：

go func() {
    // function body
}()

go-routine 调度：

• go 运行时使用 m:n 调度程序，其中 m 个 go 例程被调度到 n 个操作系统线程上。
• 这个调度程序是非抢占式的，这意味着 go 例程在空闲或逻辑阻塞时会产生控制权。

通讯与同步：

• goroutine 通常使用通道进行通信，遵循“不要通过共享内存进行通信；通过通信来共享内存”的原则。
• 对于简单的同步，您可以使用像sync.waitgroup或sync.mutex这样的原语。

示例及说明：

package main

import (
    "fmt"
    "time"
)

func printnumbers() {
    for i := 1; i <= 5; i++ {
        time.sleep(100 * time.millisecond)
        fmt.printf("%d ", i)
    }
}

func printletters() {
    for i := 'a'; i <= 'e'; i++ {
        time.sleep(150 * time.millisecond)
        fmt.printf("%c ", i)
    }
}

func main() {
    go printnumbers()
    go printletters()
    time.sleep(2 * time.second)
    fmt.println("nmain function finished")
}

说明：

• 我们定义了两个函数：printnumbers 和 printletters。
• 在 main 中，我们使用 go 关键字将这些函数作为 goroutine 启动。
• 然后 main 函数休眠 2 秒，让 goroutine 完成。
• 如果没有 goroutine，这些函数将按顺序运行。对于 goroutine，它们是同时运行的。
• 输出将显示数字和字母交错，演示并发执行。

goroutine 生命周期：

• goroutine 在使用 go 关键字创建时启动。
• 当其功能完成或程序退出时，它终止。
• 如果管理不当，goroutines 可能会泄漏，因此确保它们可以退出非常重要。

最佳实践：

• 不要在库中创建 goroutine；让调用者控制并发。
• 创建无限数量的 goroutine 时要小心。
• 使用通道或同步原语在 goroutine 之间进行协调。
• 考虑使用工作池来有效管理多个 goroutine。

带有 go 例程解释的简单示例

package main

import (
    "fmt"
    "time"
)

// printnumbers is a function that prints numbers from 1 to 5
// it will be run as a goroutine
func printnumbers() {
    for i := 1; i <= 5; i++ {
        time.sleep(500 * time.millisecond) // sleep for 500ms to simulate work
        fmt.printf("%d ", i)
    }
}

// printletters is a function that prints letters from 'a' to 'e'
// it will also be run as a goroutine
func printletters() {
    for i := 'a'; i <= 'e'; i++ {
        time.sleep(300 * time.millisecond) // sleep for 300ms to simulate work
        fmt.printf("%c ", i)
    }
}

func main() {
    // start printnumbers as a goroutine
    // the 'go' keyword before the function call creates a new goroutine
    go printnumbers()

    // start printletters as another goroutine
    go printletters()

    // sleep for 3 seconds to allow goroutines to finish
    // this is a simple way to wait, but not ideal for production code
    time.sleep(3 * time.second)

    // print a newline for better formatting
    fmt.println("nmain function finished")
}

4.频道：

通道是 go 中的一项核心功能，它允许 go 例程相互通信并同步执行。它们为一个 go 例程提供了一种将数据发送到另一个 go 例程的方法。

频道的目的

go 中的通道有两个主要用途：
a) 通信：它们允许 goroutine 相互发送和接收值。
b) 同步：它们可用于跨 goroutine 同步执行。

创建：使用 make 函数创建通道：

ch := make(chan int)  // unbuffered channel of integers

发送：使用 <- 运算符将值发送到通道：

ch <- 42  // send the value 42 to the channel

接收：使用 <- 运算符从通道接收值：

value := <-ch  // receive a value from the channel

频道类型

a) 无缓冲通道：

• 创建时没有容量： ch := make(chan int)
• 发送块直到另一个 goroutine 接收到。
• 接收会阻塞，直到另一个 goroutine 发送。

ch := make(chan int)
go func() {
    ch <- 42  // this will block until the value is received
}()
value := <-ch  // this will receive the value

b) 缓冲通道：

• 使用容量创建： ch := make(chan int, 3)
• 当缓冲区已满时仅发送块。
• 仅当缓冲区为空时才阻塞接收。

ch := make(chan int, 2)
ch <- 1  // doesn't block
ch <- 2  // doesn't block
ch <- 3  // this will block until a value is received

频道方向

通道可以是定向的或双向的：

• 双向：chan t
• 仅发送：chan<- t
• 仅接收：<-chan t

示例：

func send(ch chan<- int) {
    ch <- 42
}

func receive(ch <-chan int) {
    value := <-ch
    fmt.println(value)
}

关闭频道

可以关闭通道以表示不再发送任何值：

close(ch)

从封闭通道接收：

如果通道为空，则返回通道类型的零值。
您可以使用二值接收来检查通道是否关闭：

value, ok := <-ch
if !ok {
    fmt.println("channel is closed")
}

跨频道

您可以使用 for range 循环从通道接收值，直到通道关闭：

for value := range ch {
    fmt.Println(value)
}

嘿，感谢您坚持到最后！我感谢您成为有价值的读者和学习者。请在此处以及我的 linkedin 和 github 上关注我 .