【Go语言快速上手】第二部分：Go语言进阶之并发编程

一、并发编程

Go 语言的并发编程是其一大亮点。通过 goroutine 和 channel，Go 使得并发编程变得简洁且高效。Go 还提供了 sync 包，包含了多种同步原语，帮助开发者在并发程序中处理共享数据和同步问题。

1. goroutine：创建和调度 goroutine

goroutine 是 Go 中最基本的并发单元，可以认为是轻量级的线程。通过 go 关键字可以轻松创建一个新的 goroutine，并发执行指定的函数或方法。

package mainimport ("fmt""time"
)// 一个简单的并发任务
func sayHello() {time.Sleep(1 * time.Second)fmt.Println("Hello from goroutine!")
}func main() {go sayHello() // 创建一个 goroutinefmt.Println("Hello from main!")time.Sleep(2 * time.Second) // 等待 goroutine 执行完毕
}

在这个示例中，go sayHello() 启动了一个新的 goroutine，并发执行 sayHello 函数。主函数继续执行并打印输出，最后通过 time.Sleep 等待 goroutine 完成。

---

2. channel：无缓冲 channel、有缓冲 channel、select 语句

channel 是 Go 语言用于不同 goroutine 之间通信的机制。通过 channel，可以安全地传递数据，避免了数据竞争问题。Go 提供了无缓冲和有缓冲的 channel，以及 select 语句来处理多个 channel 的操作。

2.1 无缓冲 channel

无缓冲 channel 会在发送数据和接收数据时进行同步，确保发送和接收操作相互配合。

package mainimport "fmt"func main() {ch := make(chan string) // 创建一个无缓冲 channel// 启动 goroutine 发送数据go func() {ch <- "Hello from goroutine!" // 向 channel 发送数据}()// 接收数据msg := <-chfmt.Println(msg) // 输出: Hello from goroutine!
}

2.2 有缓冲 channel

有缓冲的 channel 可以在发送数据时不必立即等待接收方，直到缓冲区满或接收方取走数据。创建有缓冲 channel 时，可以指定缓冲区的大小。

package mainimport "fmt"func main() {ch := make(chan string, 2) // 创建一个缓冲区大小为 2 的 channelch <- "Hello"ch <- "World" // 向 channel 发送两个消息fmt.Println(<-ch)fmt.Println(<-ch)
}

在这个示例中，channel 的缓冲区大小为 2，可以在不立即接收的情况下向 channel 发送两个数据。

2.3 select 语句

select 语句允许你等待多个 channel 操作。它类似于 switch 语句，但用于处理多个 channel 的发送或接收。

package mainimport ("fmt""time"
)func main() {ch1 := make(chan string)ch2 := make(chan string)go func() {time.Sleep(1 * time.Second)ch1 <- "Message from ch1"}()go func() {time.Sleep(2 * time.Second)ch2 <- "Message from ch2"}()// 使用 select 语句监听多个 channelselect {case msg1 := <-ch1:fmt.Println("Received:", msg1)case msg2 := <-ch2:fmt.Println("Received:", msg2)}
}

在这个示例中，select 会等待 ch1 或 ch2 中的任一 channel 可用。当第一个 channel 可用时，它会立即执行对应的 case，并停止等待。

---

3. sync 包：Mutex、RWMutex、WaitGroup 等同步原语

Go 提供了 sync 包中的多种同步原语，用于处理并发程序中的共享资源访问问题。

3.1 Mutex：互斥锁

Mutex 是最常用的同步原语，它确保同一时刻只有一个 goroutine 可以访问共享资源。通过 Lock 和 Unlock 方法来加锁和解锁。

package mainimport ("fmt""sync"
)var counter int
var mutex sync.Mutexfunc increment() {mutex.Lock() // 加锁counter++mutex.Unlock() // 解锁
}func main() {var wg sync.WaitGroup// 启动多个 goroutine 进行并发操作for i := 0; i < 1000; i++ {wg.Add(1)go func() {defer wg.Done()increment()}()}wg.Wait() // 等待所有 goroutine 执行完毕fmt.Println("Final counter:", counter)
}

在这个示例中，使用 Mutex 来保证对 counter 的并发访问是安全的。

3.2 RWMutex：读写互斥锁

RWMutex 是一种读写互斥锁，它允许多个 goroutine 同时读取共享资源，但在写操作时会阻止其他的读写操作。

package mainimport ("fmt""sync"
)var counter int
var rwMutex sync.RWMutexfunc read() int {rwMutex.RLock() // 读锁defer rwMutex.RUnlock()return counter
}func write() {rwMutex.Lock() // 写锁counter++rwMutex.Unlock()
}func main() {var wg sync.WaitGroup// 启动多个 goroutine 进行读写操作for i := 0; i < 1000; i++ {wg.Add(1)go func() {defer wg.Done()write()}()}for i := 0; i < 1000; i++ {wg.Add(1)go func() {defer wg.Done()read()}()}wg.Wait()fmt.Println("Final counter:", counter)
}

在这个示例中，RWMutex 允许多个 goroutine 同时进行读操作，但在执行写操作时会锁住资源。

3.3 WaitGroup：等待多个 goroutine 完成

WaitGroup 用于等待一组 goroutine 执行完毕。它提供了 Add、Done 和 Wait 方法来控制并发流程。

package mainimport ("fmt""sync"
)func task(wg *sync.WaitGroup) {defer wg.Done() // 执行完毕时调用 Donefmt.Println("Task completed")
}func main() {var wg sync.WaitGroup// 启动多个 goroutinefor i := 0; i < 5; i++ {wg.Add(1) // 增加等待的 goroutine 数量go task(&wg)}wg.Wait() // 等待所有 goroutine 执行完毕fmt.Println("All tasks completed")
}

在这个示例中，WaitGroup 用于等待多个并发任务完成。