Concurrency in Go: From Basics to Advanced Concepts

目录

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 



<p><strong>说明：</strong></p>

• 我们定义了两个函数：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 



<p><strong>4.频道：</strong></p>

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

<p><strong>频道的目的</strong></p>

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

<p>创建：使用 make 函数创建通道：<br>
</p>

<pre class="brush:php;toolbar:false">ch := make(chan int)  // Unbuffered channel of integers

发送：使用

ch 



<p>Receiving: Values are received from a channel using the 
</p>

<pre class="brush:php;toolbar:false">value := 



<p><strong>Types of Channels</strong></p>

<p>a) Unbuffered Channels:</p>

• Created without a capacity: ch := make(chan int)
• Sending blocks until another goroutine receives.
• Receiving blocks until another goroutine sends.

ch := make(chan int)
go func() {
    ch 



<p>b) Buffered Channels:</p>

• Created with a capacity: ch := make(chan int, 3)
• Sending only blocks when the buffer is full.
• Receiving only blocks when the buffer is empty.

ch := make(chan int, 2)
ch 



<p><strong>Channel Directions</strong></p>

<p>Channels can be directional or bidirectional:</p>

• Bidirectional: chan T
• Send-only: chan
• Receive-only:

Example :

func send(ch chan



<p><strong>Closing Channels</strong></p>

<p>Channels can be closed to signal that no more values will be sent:<br>
</p>

<pre class="brush:php;toolbar:false">close(ch)

Receiving from a closed channel:

If the channel is empty, it returns the zero value of the channel's type.
You can check if a channel is closed using a two-value receive:

value, ok := 



<p><strong>Ranging over Channels</strong></p>

<p>You can use a for range loop to receive values from a channel until it's closed:<br>
</p>

<pre class="brush:php;toolbar:false">for value := range ch {
    fmt.Println(value)
}

Hey, Thank you for staying until the end! I appreciate you being valuable reader and learner. Please follow me here and also on my Linkedin and GitHub .

The above is the detailed content of Concurrency in Go: From Basics to Advanced Concepts. For more information, please follow other related articles on the PHP Chinese website!