并发与并行,同步和异步,Go lang1.18入门精炼教程,由白丁入鸿儒,Go lang并发编程之GoroutineEP13

简介: 如果说Go lang是静态语言中的皇冠,那么,Goroutine就是并发编程方式中的钻石。Goroutine是Go语言设计体系中最核心的精华,它非常轻量,一个 Goroutine 只占几 KB,并且这几 KB 就足够 Goroutine 运行完,这就能在有限的内存空间内支持大量 Goroutine协程任务,方寸之间,运筹帷幄,用极少的成本获取最高的效率,支持了更多的并发,毫无疑问,Goroutine是比Python的协程原理事件循环更高级的并发异步编程方式。

如果说Go lang是静态语言中的皇冠,那么,Goroutine就是并发编程方式中的钻石。Goroutine是Go语言设计体系中最核心的精华,它非常轻量,一个 Goroutine 只占几 KB,并且这几 KB 就足够 Goroutine 运行完,这就能在有限的内存空间内支持大量 Goroutine协程任务,方寸之间,运筹帷幄,用极少的成本获取最高的效率,支持了更多的并发,毫无疑问,Goroutine是比Python的协程原理事件循环更高级的并发异步编程方式。

GMP调度模型(Goroutine-Machine-Processor)

为什么Goroutine比Python的事件循环高级?是因为Go lang的调度模型GMP可以参与系统内核线程中的调度,这里G为Goroutine,是被调度的最小单元;M是系统起了多少个线程;P为Processor,也就是CPU处理器,调度器的核心处理器,通常表示执行上下文,用于匹配 M 和 G 。P 的数量不能超过 GOMAXPROCS 配置数量,这个参数的默认值为当前电脑的总核心数,通常一个 P 可以与多个 M 对应,但同一时刻,这个 P 只能和其中一个 M 发生绑定关系;M 被创建之后需要自行在 P 的 free list 中找到 P 进行绑定,没有绑定 P 的 M,会进入阻塞状态,每一个P最多关联256个G。

说白了,就是GMP和Python一样,也是维护一个任务队列,只不过这个任务队列是通过Goroutine来调度,怎么调度?通过Goroutine和系统线程M的协商,寻找非阻塞的通道,进入P的本地小队列,然后交给系统内的CPU执行,藉此,充分利用了CPU的多核资源。

而Python的协程方式仅仅停留在用户态,它没法参与到线程内核的调度,弥补方式是单线程多协程任务下开多进程,Go lang则是全权交给Goroutine,用户不需要参与底层操作,同时又可以利用CPU的多核资源。

启动Goroutine

首先默认情况下,golang程序还是由上自下的串行方式:

package main  
  
import (  
    "fmt"  
)  
  
func job() {  
    fmt.Println("任务执行")  
}  
func main() {  
    job()  
    fmt.Println("任务执行完了")  
}

程序返回:

任务执行  
任务执行完了

这里job中的打印函数是先于main中的打印函数。

现在,在执行job函数前面加上关键字go,也就是启动一个goroutine去执行job这个函数:

package main  
  
import (  
    "fmt"  
    "time"  
)  
  
func job() {  
    fmt.Println("任务执行")  
}  
func main() {  
    go job()  
    fmt.Println("任务执行完了")  
    time.Sleep(time.Second)  
}

注意,开启Goroutine是在函数执行的时候开启,并非声明的时候,程序返回:



任务执行完了  
任务执行

可以看到,执行顺序颠倒了过来,首先为什么会先打印任务执行完了,是因为系统在创建新的Goroutine的时候需要耗费一些资源,因为就算只有几kb,也需要时间来创建,而此时main函数所在的goroutine是继续执行的。

第二,为什么要人为的把main函数延迟一秒钟?

因为当main()函数返回的时候main所在的Goroutine就结束了,所有在main()函数中启动的goroutine会一同结束,所以这里必须人为的“阻塞”一下main函数,让它后于job结束,有点像公园如果要关门必须等最后一个游客走了才能关,否则就把游客关在公园里了,出不去了。

与此同时,此逻辑和Python中的线程阻塞逻辑非常一致,用过Python多线程的朋友肯定知道要想让所有子线程都执行完毕,必须阻塞主线程,不能让主线程提前执行完,这和Goroutine有异曲同工之妙。

在Go lang中实现并发编程就是如此轻松,我们还可以启动多个Goroutine:



package main  
  
import (  
    "fmt"  
    "sync"  
)  
  
var wg sync.WaitGroup  
  
func job(i int) {  
    defer wg.Done() // 协程结束就通知  
    fmt.Println("协程任务执行", i)  
}  
func main() {  
  
    for i := 0; i < 10; i++ {  
        wg.Add(1) // 启动协程任务后入队  
        go job(i)  
    }  
    wg.Wait() // 等待所有登记的goroutine都结束  
  
    fmt.Println("所有任务执行完毕")  
}  


程序返回:



协程任务执行 8  
协程任务执行 9  
协程任务执行 5  
协程任务执行 0  
协程任务执行 1  
协程任务执行 4  
协程任务执行 7  
协程任务执行 2  
协程任务执行 3  
协程任务执行 6  
所有任务执行完毕

这里我们摒弃了相对土鳖的time.Sleep(time.Second)方式,而是采用sync包的WaitGroup方式,原理是当启动协程任务后,在WaitGroup登记,当每个协程任务执行完成后,通知WaitGroup,直到所有的协程任务都执行完毕,然后再执行main函数所在的协程,所以“所有任务执行完毕”会在所有协程任务执行完毕后再打印。

和Python协程区别

我们再来看看,如果是Python,会怎么做?



import asyncio  
import random  
  
async def job(i):  
  
    print("协程任务执行{}".format(i))  
    await asyncio.sleep(random.randint(1,5))  
    print("协程任务结束{}".format(i))  
  
  
  
async def main():  
  
    tasks = [asyncio.create_task(job(i)) for i in range(10)]  
      
    res = await asyncio.gather(*tasks)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

程序返回:

协程任务执行0  
协程任务执行1  
协程任务执行2  
协程任务执行3  
协程任务执行4  
协程任务执行5  
协程任务执行6  
协程任务执行7  
协程任务执行8  
协程任务执行9  
协程任务结束0  
协程任务结束1  
协程任务结束3  
协程任务结束6  
协程任务结束9  
协程任务结束8  
协程任务结束2  
协程任务结束4  
协程任务结束5  
协程任务结束7

可以看到,Python协程工作的前提是,必须在同一个事件循环中,同时逻辑内必须由用户来手动切换,才能达到“并发”的工作方式,假设,如果我们不手动切换呢?

import asyncio  
import random  
  
async def job(i):  
  
    print("协程任务执行{}".format(i))  
    print("协程任务结束{}".format(i))  
  
  
  
async def main():  
  
    tasks = [asyncio.create_task(job(i)) for i in range(10)]  
      
    res = await asyncio.gather(*tasks)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

程序返回:

协程任务执行0  
协程任务结束0  
协程任务执行1  
协程任务结束1  
协程任务执行2  
协程任务结束2  
协程任务执行3  
协程任务结束3  
协程任务执行4  
协程任务结束4  
协程任务执行5  
协程任务结束5  
协程任务执行6  
协程任务结束6  
协程任务执行7  
协程任务结束7  
协程任务执行8  
协程任务结束8  
协程任务执行9  
协程任务结束9

一望而知,只要你不手动切任务,它就立刻回到了“串行”的工作方式,同步的执行任务,那么协程的意义在哪儿呢?

所以,归根结底,Goroutine除了可以极大的利用系统多核资源,它还能帮助开发者来切换协程任务,简化开发者的工作,说白了就是,不懂协程工作原理,也能照猫画虎写go lang代码,但如果不懂协程工作原理的前提下,写Python协程并发逻辑呢?恐怕够呛吧。

结语

综上,Goroutine的工作方式,就是多个协程在多个线程上切换,既可以用到多核,又可以减少切换开销。但有光就有影,有利就有弊,Goroutine确实不需要开发者过度参与,但这样开发者就少了很多自由度,一些定制化场景下,就只能采用单一的Goroutine手段,比如一些纯IO密集型任务场景,像爬虫,你有多少cpu的意义并不大,因为cpu老是等着你的io操作,所以Python这种协程工作方式在纯IO密集型任务场景下并不逊色于Goroutine。

相关文章
|
8天前
|
监控 算法 Go
Golang深入浅出之-Go语言中的服务熔断、降级与限流策略
【5月更文挑战第4天】本文探讨了分布式系统中保障稳定性的重要策略:服务熔断、降级和限流。服务熔断通过快速失败和暂停故障服务调用来保护系统;服务降级在压力大时提供有限功能以保持整体可用性;限流控制访问频率,防止过载。文中列举了常见问题、解决方案,并提供了Go语言实现示例。合理应用这些策略能增强系统韧性和可用性。
59 0
|
8天前
|
Go
深度探讨 Golang 中并发发送 HTTP 请求的最佳技术
深度探讨 Golang 中并发发送 HTTP 请求的最佳技术
|
8天前
|
分布式计算 Java Go
Golang深入浅出之-Go语言中的分布式计算框架Apache Beam
【5月更文挑战第6天】Apache Beam是一个统一的编程模型,适用于批处理和流处理,主要支持Java和Python,但也提供实验性的Go SDK。Go SDK的基本概念包括`PTransform`、`PCollection`和`Pipeline`。在使用中,需注意类型转换、窗口和触发器配置、资源管理和错误处理。尽管Go SDK文档有限,生态系统尚不成熟,且性能可能不高,但它仍为分布式计算提供了可移植的解决方案。通过理解和掌握Beam模型,开发者能编写高效的数据处理程序。
142 1
|
8天前
|
缓存 测试技术 持续交付
Golang深入浅出之-Go语言中的持续集成与持续部署(CI/CD)
【5月更文挑战第5天】本文介绍了Go语言项目中的CI/CD实践,包括持续集成与持续部署的基础知识,常见问题及解决策略。测试覆盖不足、版本不一致和构建时间过长是主要问题,可通过全面测试、统一依赖管理和利用缓存优化。文中还提供了使用GitHub Actions进行自动化测试和部署的示例,强调了持续优化CI/CD流程以适应项目需求的重要性。
57 1
|
8天前
|
Kubernetes Cloud Native Go
Golang深入浅出之-Go语言中的云原生开发:Kubernetes与Docker
【5月更文挑战第5天】本文探讨了Go语言在云原生开发中的应用,特别是在Kubernetes和Docker中的使用。Docker利用Go语言的性能和跨平台能力编写Dockerfile和构建镜像。Kubernetes,主要由Go语言编写,提供了方便的客户端库与集群交互。文章列举了Dockerfile编写、Kubernetes资源定义和服务发现的常见问题及解决方案,并给出了Go语言构建Docker镜像和与Kubernetes交互的代码示例。通过掌握这些技巧,开发者能更高效地进行云原生应用开发。
62 1
|
8天前
|
负载均衡 监控 Go
Golang深入浅出之-Go语言中的服务网格(Service Mesh)原理与应用
【5月更文挑战第5天】服务网格是处理服务间通信的基础设施层,常由数据平面(代理,如Envoy)和控制平面(管理配置)组成。本文讨论了服务发现、负载均衡和追踪等常见问题及其解决方案,并展示了使用Go语言实现Envoy sidecar配置的例子,强调Go语言在构建服务网格中的优势。服务网格能提升微服务的管理和可观测性,正确应对问题能构建更健壮的分布式系统。
31 1
|
8天前
|
消息中间件 Go API
Golang深入浅出之-Go语言中的微服务架构设计与实践
【5月更文挑战第4天】本文探讨了Go语言在微服务架构中的应用,强调了单一职责、标准化API、服务自治和容错设计等原则。同时,指出了过度拆分、服务通信复杂性、数据一致性和部署复杂性等常见问题,并提出了DDD拆分、使用成熟框架、事件驱动和配置管理与CI/CD的解决方案。文中还提供了使用Gin构建HTTP服务和gRPC进行服务间通信的示例。
33 0
|
8天前
|
Prometheus 监控 Cloud Native
Golang深入浅出之-Go语言中的分布式追踪与监控系统集成
【5月更文挑战第4天】本文探讨了Go语言中分布式追踪与监控的重要性,包括追踪的三个核心组件和监控系统集成。常见问题有追踪数据丢失、性能开销和监控指标不当。解决策略涉及使用OpenTracing或OpenTelemetry协议、采样策略以及聚焦关键指标。文中提供了OpenTelemetry和Prometheus的Go代码示例,强调全面可观测性对微服务架构的意义,并提示选择合适工具和策略以确保系统稳定高效。
148 5
|
8天前
|
负载均衡 算法 Go
Golang深入浅出之-Go语言中的服务注册与发现机制
【5月更文挑战第4天】本文探讨了Go语言中服务注册与发现的关键原理和实践,包括服务注册、心跳机制、一致性问题和负载均衡策略。示例代码演示了使用Consul进行服务注册和客户端发现服务的实现。在实际应用中,需要解决心跳失效、注册信息一致性和服务负载均衡等问题,以确保微服务架构的稳定性和效率。
23 3
|
8天前
|
前端开发 Go
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式
【5月更文挑战第3天】Go语言通过goroutines和channels实现异步编程,虽无内置Future/Promise,但可借助其特性模拟。本文探讨了如何使用channel实现Future模式,提供了异步获取URL内容长度的示例,并警示了Channel泄漏、错误处理和并发控制等常见问题。为避免这些问题,建议显式关闭channel、使用context.Context、并发控制机制及有效传播错误。理解并应用这些技巧能提升Go语言异步编程的效率和健壮性。
30 5
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式