golang学习笔记11——Go 语言的并发与同步实现详解

• 推荐学习文档
  • golang应用级os框架，欢迎star
  • 基于golang开发的一款超有个性的旅游计划app经历
  • golang实战大纲
  • golang优秀开发常用开源库汇总
  • golang学习笔记01——基本数据类型
  • golang学习笔记02——gin框架及基本原理
  • golang学习笔记03——gin框架的核心数据结构
  • golang学习笔记04——如何真正写好Golang代码？
  • golang学习笔记05——golang协程池，怎么实现协程池？
  • golang学习笔记06——怎么实现本地文件及目录监控-fsnotify
  • golang学习笔记07——使用gzip压缩字符减少redis等存储占用的实现
  • golang学习笔记08——如何调用阿里oss sdk实现访问对象存储？
  • golang学习笔记09——golang优秀开发常用开源库汇总
  • golang学习笔记10——golang 的 Gin 框架，快速构建高效 Web 应用

引言

在现代软件开发中，并发和同步是非常重要的概念。Go 语言以其简洁高效的并发模型而备受关注。本文将详细介绍 Go 语言中并发与同步的实现方式，并结合代码示例进行深入讲解。

Go 语言的并发模型

1.goroutine

• Goroutine 是 Go 语言中实现并发的轻量级线程。与传统的线程相比，goroutine 占用的内存更少，创建和切换的开销也更小。
• 创建 goroutine 非常简单，只需要在函数调用前加上 go 关键字即可。例如：

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go printNumbers()
    fmt.Println("Main function")
    time.Sleep(time.Second * 2)
}

在上面的代码中，printNumbers 函数会在一个新的 goroutine 中执行，而 main 函数会继续执行。这样就实现了并发执行两个任务。

2.channel

• channel 是用于 goroutine 之间通信的机制。它可以在不同的 goroutine 之间传递数据，实现同步和协调。
• 创建 channel 可以使用 make 函数。例如：ch := make(chan int) 创建了一个整数类型的 channel。
• 可以使用 <- 操作符从 channel 中接收数据或向 channel 中发送数据。例如：

package main

import (
    "fmt"
)

func sendData(ch chan int) {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
    close(ch)
}

func main() {
    ch := make(chan int)
    go sendData(ch)
    for num := range ch {
        fmt.Println(num)
    }
}

在上面的代码中，sendData 函数会向 channel 中发送数据，而 main 函数会从 channel 中接收数据。当 sendData 函数发送完所有数据后，会关闭 channel。main 函数中的 for range 循环会自动检测 channel 的关闭，并退出循环。

Go 语言的同步机制

1.mutex

• mutex（互斥锁）是一种用于保护共享资源的同步机制。在 Go 语言中，可以使用 sync.Mutex 类型来实现互斥锁。
• 使用互斥锁的步骤如下：
  • 创建一个 sync.Mutex 类型的变量。
  • 在需要保护的代码块前，调用 Lock 方法获取锁。
  • 在代码块执行完毕后，调用 Unlock 方法释放锁。
• 例如：

package main

import (
    "fmt"
    "sync"
)

var counter int
var mutex sync.Mutex

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    counter++
    fmt.Println(counter)
}

func main() {
    for i := 0; i < 5; i++ {
        go increment()
    }
    // 等待所有 goroutine 执行完毕
    time.Sleep(time.Second)
}

在上面的代码中，increment 函数会对共享变量 counter 进行加一操作。为了避免多个 goroutine 同时访问和修改 counter 变量，使用了互斥锁 mutex。在 increment 函数中，首先调用 Lock 方法获取锁，然后对 counter 进行加一操作，最后调用 Unlock 方法释放锁。

2.wait group

• WaitGroup 是一种用于等待一组 goroutine 执行完毕的同步机制。在 Go 语言中，可以使用 sync.WaitGroup 类型来实现 WaitGroup。
• 使用 WaitGroup 的步骤如下：
  • 创建一个 sync.WaitGroup 类型的变量。
  • 在每个需要等待的 goroutine 中，调用 Add 方法增加等待的 goroutine 数量。
  • 在 goroutine 执行完毕后，调用 Done 方法减少等待的 goroutine 数量。
  • 在主 goroutine 中，调用 Wait 方法等待所有 goroutine 执行完毕。
• 例如：

package main

import (
    "fmt"
    "sync"
)

func process(wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println("Processing...")
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go process(&wg)
    }
    wg.Wait()
    fmt.Println("All processes completed.")
}

在上面的代码中，process 函数会模拟一个处理过程。在主 goroutine 中，创建了一个 sync.WaitGroup 类型的变量 wg。然后，在循环中启动了 5 个 goroutine，并在每个 goroutine 中调用 Add 方法增加等待的 goroutine 数量。在每个 goroutine 执行完毕后，会调用 Done 方法减少等待的 goroutine 数量。最后，在主 goroutine 中，调用 Wait 方法等待所有 goroutine 执行完毕。

总结

Go 语言的并发与同步机制使得开发者能够轻松地编写高效的并发程序。通过 goroutine 和 channel，开发者可以实现轻量级的并发编程，提高程序的性能和响应速度。同时，通过 mutex 和 wait group 等同步机制，开发者可以保护共享资源，确保程序的正确性。在实际开发中，开发者可以根据具体的需求选择合适的并发和同步机制，以实现高效、可靠的程序。

关注我看更多有意思的文章哦！