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

文章目录

引言

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

Go 语言的并发模型

1.goroutine

  • Goroutine 是 Go 语言中实现并发的轻量级线程。与传统的线程相比,goroutine 占用的内存更少,创建和切换的开销也更小。
  • 创建 goroutine 非常简单,只需要在函数调用前加上 go 关键字即可。例如:
golang 复制代码
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 中发送数据。例如:
golang 复制代码
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 方法释放锁。
  • 例如:
golang 复制代码
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 执行完毕。
  • 例如:
golang 复制代码
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 等同步机制,开发者可以保护共享资源,确保程序的正确性。在实际开发中,开发者可以根据具体的需求选择合适的并发和同步机制,以实现高效、可靠的程序。

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

相关推荐
试着12 分钟前
零基础学习性能测试第五章:JVM性能分析与调优-垃圾回收器的分类与回收
jvm·学习·零基础·性能测试·垃圾回收器
livemetee17 分钟前
Flink2.0学习笔记:Stream API 常用转换算子
大数据·学习·flink
WXX_s20 分钟前
【OpenCV篇】OpenCV——03day.图像预处理(2)
人工智能·python·opencv·学习·计算机视觉
艾莉丝努力练剑1 小时前
【LeetCode&数据结构】二叉树的应用(二)——二叉树的前序遍历问题、二叉树的中序遍历问题、二叉树的后序遍历问题详解
c语言·开发语言·数据结构·学习·算法·leetcode·链表
YGY Webgis糕手之路1 小时前
OpenLayers 快速入门(九)Extent 介绍
前端·经验分享·笔记·vue·web
花月mmc1 小时前
CanMV-K230 AI学习笔记系列
人工智能·笔记·学习
码事漫谈1 小时前
C++模板元编程从入门到精通
后端
_風箏1 小时前
Java【代码 14】一个用于判断磁盘空间和分区表是否需要清理的工具类
后端
_風箏1 小时前
Java【代码 13】前端动态添加一条记后端使用JDK1.8实现map对象根据key的部分值进行分组(将map对象封装成指定entity对象)
后端
_風箏1 小时前
Java【代码 12】判断一个集合是否包含另一个集合中的一个或多个元素 retainAll() 及其他方法
后端