Golang的Goroutine（协程）与runtime

目录

Runtime 包概述

Runtime 包常用函数

1. GOMAXPROCS

2. Caller 和 Callers

3. BlockProfile 和 Stack

理解Golang的Goroutine

Goroutine的基本概念

特点：

Goroutine的创建与启动

示例代码

解释

Goroutine的调度

Gosched的作用

示例代码

输出

解释

Goroutine的性能优化

示例代码

解释

实际应用中的使用场景

总结

Runtime与Routine的关系

补充（代码）

Runtime 包概述

runtime 包提供了与 Go 运行时环境交互的功能，包括 goroutine 调度、内存管理、堆栈操作等。通过 runtime 包，我们可以更好地控制程序的运行行为。

Runtime 包常用函数

1. GOMAXPROCS

设置可以并行执行的最大 CPU 数，并返回之前的设置值。

fmt.Println(runtime.GOMAXPROCS(2))

2. Caller 和 Callers

runtime.Caller 和 runtime.Callers 用于获取调用栈信息。

pc, file, line, ok := runtime.Caller(1)  
if !ok {  fmt.Println("runtime.Caller() failed")  return  
}  
fmt.Printf("PC: %v, File: %s, Line: %d\n", pc, file, line)

3. BlockProfile 和 Stack

runtime.BlockProfile() 用于获取阻塞概述，而 runtime.Stack() 则可以打印当前 goroutine 或所有 goroutine 的堆栈跟踪信息。

理解Golang的Goroutine

Goroutine是Golang语言中的轻量级线程，能够在单一操作系统线程上运行多个Goroutine，从而提高并发编程的效率。本文将通过实际的代码示例，详细讲解Goroutine的创建、调度、性能优化以及在实际应用中的使用场景。

    Goroutine的基本概念

    Goroutine 是Golang语言中用于并发编程的基本单位。与传统的线程（Thread）相比，Goroutine的调度和切换成本更低，因为它们是基于Golang的协作式调度模型设计的。每个Goroutine的栈大小默认为2KB，但随着其生命周期的变化，栈大小会自动扩大以适应需求。

    特点：

    • 轻量级：创建和销毁Goroutine的开销非常低。
    • 高并发：Golang可以轻松支持数万甚至更多的Goroutine同时运行。
    • ** Channels**：Goroutine之间通过Channel进行通信，避免了共享内存带来的竞态条件问题。

    Goroutine的创建与启动

    Goroutine的创建非常简单，只需要在函数调用前加上go关键字即可启动一个新的Goroutine。

    示例代码
    package mainimport ("fmt""runtime"
)func print() {fmt.Println("这是一个新的Goroutine。")
}func main() {go print()  // 启动一个新的Goroutinefmt.Println("主Goroutine结束。")  // 主Goroutine继续执行
}

    解释

    • go print()：启动一个新的Goroutine执行print函数。
    • 主Goroutine继续执行fmt.Println("主Goroutine结束。")。
    • 需要注意的是，如果主Goroutine执行完毕，程序可能会直接退出，可能无法看到子Goroutine的输出。为了确保子Goroutine有足够的时间完成，可以通过time.Sleep()或者其他同步机制来控制。

    Goroutine的调度

    Goroutine的调度是由Golang的运行时环境负责的。与线程不同，Goroutine采用的是非抢占式调度，即只有在当前Goroutine主动让出CPU（例如调用runtime.Gosched()）时，其他Goroutine才能获取执行机会。

    Gosched的作用

    runtime.Gosched()用于让出当前Goroutine的执行权限，允许其他Goroutine运行。

    示例代码
    package mainimport ("fmt""runtime"
)func main() {go func() {for i := 1; i <= 5; i++ {runtime.Gosched()fmt.Println(i)}}()fmt.Println("主Goroutine结束。")
}
    输出
    主Goroutine结束。
1
2
3
4
5

    解释

    • 子Goroutine在循环中调用runtime.Gosched()，主动让出CPU时间片。
    • 主Goroutine在子Goroutine开始后立即执行并输出“主Goroutine结束。”。

    Goroutine的性能优化

    Goroutine的性能优化主要体现在以下几个方面：

    1. 设置GOMAXPROCS：通过runtime.GOMAXPROCS(n)设置可以并行执行的最大CPU核数。合理设置这个值可以提高程序的并行度。

      • 示例：runtime.GOMAXPROCS(2)，表示最多同时使用2个CPU核心。

    2. 避免竞态条件：多个Goroutine访问共享变量时，可能会出现竞态条件。可以通过Channel或sync包中的同步原语（如Mutex、RWMutex）来避免。

    3. 合理分配任务：在高并发场景下，合理分配任务可以提高程序的执行效率。

    示例代码
    package mainimport ("fmt""math""runtime""sync""time"
)func findPrime(num int, inChan chan int, primeChan chan int, exitChan chan bool) {var flag boolfor {v, ok := <-inChanif !ok {break}flag = truefor i := 2; i < int(math.Sqrt(float64(v))); i++ {if v % i == 0 {flag = falsebreak}}if flag {primeChan <- v}}exitChan <- true
}func main() {num := 10000000  // 查找小于num的所有质数start := time.Now()inChan := make(chan int, num)primeChan := make(chan int, num)exitChan := make(chan bool, 4)  // 假设使用4个Goroutinego func() {for i := 2; i < num; i++ {inChan <- i}close(inChan)}()for i := 0; i < 4; i++ {go findPrime(num, inChan, primeChan, exitChan)}go func() {for i := 0; i < 4; i++ {<-exitChan}close(primeChan)}()count := 0for v := range primeChan {count++}fmt.Printf("找到%d个质数，用时：%v\n", count, time.Since(start))
}

    解释

    • Channel通信：通过Channel传递数据，避免了共享变量带来的竞态条件。
    • 并行计算：通过启动多个Goroutine并行计算质数，提高了程序的执行效率。
    • 同步机制：通过exitChan等待所有Goroutine完成任务。

    实际应用中的使用场景

    1. 并发请求处理：在Web服务器中，通过Goroutine并行处理多个HTTP请求，提高吞吐量。
    2. 数据处理：在数据处理任务中，通过Goroutine并行处理不同的数据片段，提高处理速度。
    3. I/O密集型任务：在I/O密集型任务（如文件读写、网络通信）中，Goroutine可以通过非阻塞的方式提高资源利用率。

    总结

    Goroutine是Golang语言中的并行编程核心，具有轻量级、高效和灵活的特点。通过合理利用Goroutine，可以显著提高程序的性能和响应速度。在实际应用中，需要注意避免竞态条件，合理分配任务，并通过Channel等方式实现Goroutine之间的安全通信。

    Runtime与Routine的关系

    在Go语言中，runtime和routine是两个密切相关但又有明确区别的概念。runtime主要指的是Go语言的运行时环境，它为Go程序的执行提供了必要的支持，如内存管理、Goroutine调度、错误处理等。而routine在Go语言中特指Goroutine，即轻量级的线程。

    具体来说：

    1. Runtime

      • 定义：runtime是一个Go语言标准库中的包，提供了与程序运行时环境相关的功能。
      • 功能：
        • Goroutine调度：管理Goroutine的创建、执行和调度。
        • 内存管理：负责内存的分配和回收，包括垃圾回收机制。
        • 错误处理：提供了一些与错误处理相关的函数，如runtime.Error。
        • 与操作系统交互：处理程序运行时的环境，如线程数、CPU核数等。
        • 性能监控：提供了一些与性能监控相关的函数，如内存使用统计。
      • 常用函数：
        • Gosched()：让出当前Goroutine的执行权限，允许其他Goroutine运行。
        • GOMAXPROCS()：设置或获取可以并行执行用户级处理的最大CPU核数。
        • NumCPU()：返回当前可用的CPU核数。
        • Goexit()：使当前Goroutine退出，然后调度器会打印当前的栈跟踪信息。

    2. Routine（Goroutine）

      • 定义：Goroutine是Go语言中的轻量级线性，它由Go的运行时环境管理。
      • 特点：
        • 轻量级：创建和销毁Goroutine的开销比传统线程低。
        • 高并发：可以轻松支持数万甚至更多的Goroutine同时运行。
        • 非阻塞式调度：基于协作式调度，主动让出CPU时间片。
      • 创建方式：通过go关键字启动一个新的Goroutine。
      • 常见用途：
        • 并发执行任务：将一个函数或方法转换为异步执行，不阻塞主Goroutine。
        • 处理I/O密集型任务：在I/O操作中，释放资源让其他Goroutine使用。
        • 并行计算：在多核CPU上并行执行任务以提高计算效率。

    3. 两者的关系

      • 调度管理：runtime包负责管理Goroutine的调度，包括如何分配时间片、如何在多个CPU核间分配Goroutine等。
      • 资源管理：通过runtime包，可以控制Goroutine的数量和并行度，优化程序性能。
      • 协作式调度：Goroutine通过runtime.Gosched()主动让出CPU时间片，协作式调度依赖于Goroutine自身的配合，而不是操作系统强制切换。

    补充（代码）

    package mainimport ("fmt""math""runtime""time"
)func PrintCallerInfo() {//返回调用栈的信息（文件名、行号等）。//参数：skip表示从调用Caller开始往回数多少层的调用栈信息。// 	skip = 0: 返回调用runtime.Caller的函数（即直接包含runtime.Caller(0)调用的那行代码）的文件名、行号等信息。// skip = 1: 返回调用runtime.Caller所在函数的直接调用者的文件名和行号。换句话说，就是调用了包含runtime.Caller(1)的函数的地方的调用栈信息。// skip = 2: 返回上一步调用者的调用者信息，依此类推。每增加1，就向上追溯一个调用栈帧。// 以此类推，随着skip值的增加，可以逐级向上追溯到更早的调用栈信息。如果指定的层级超出了实际存在的调用栈层数，则ok将为false，其他返回值（pc, file, line）将没有意义或为零值。pc, file, line, ok := runtime.Caller(1)if !ok {fmt.Println("runtime.Caller() failed")return}fmt.Printf("PC: %v, File: %s, Line: %d\n", pc, file, line)
}func main() {// 设置可以并行执行的最大CPU数，并返回之前的设置值；控制了Go程序可以同时使用的操作系统线程数量。fmt.Println(runtime.GOMAXPROCS(2))// 启动一个协程go func(x int) {//time.Sleep(1 * time.Second)fmt.Println("Goroutine", x)}(1)// 终止go func(x int) {defer fmt.Println("Goroutine", x)//time.Sleep(1 * time.Second)runtime.Goexit() // 当前goroutine 退出fmt.Println("This won't print")}(2)// 当前程序中活跃的gotoutines数量fmt.Println("NumGoroutine:", runtime.NumGoroutine())// 让出当前goroutine的处理器，允许其他等待的goroutines运行；// 这是一个提示，而不是强制性的上下文呢切换go func() {for i := 1; i <= 5; i++ {runtime.Gosched()fmt.Println(i)}}()go func(x int) {//time.Sleep(1 * time.Second)fmt.Println("Goroutine", x)}(3)go func(x int) {//time.Sleep(1 * time.Second)fmt.Println("Goroutine", x)}(4)// 其它//runtime.BlockProfile() //获取当前的阻塞概要信息（block profile），它用于分析goroutine之间的同步问题，如锁竞争、通道阻塞等。//runtime.Caller() //返回调用栈的信息（文件名、行号等）。//runtime.Callers() //类似Caller，但返回的是多个调用栈帧的信息。//runtime.GC() //：手动触发垃圾回收。通常不需要手动调用，Go的垃圾收集器会自动管理内存。fmt.Println(runtime.GOROOT()) // 返回Go的安装目录//runtime.KeepAlive(x any) //确保对象在其作用域结束前不会被垃圾回收。//runtime.Stack() //将当前goroutine或所有goroutines的堆栈跟踪写入提供的缓冲区。// runtime.Caller//PrintCallerInfo()//time.Sleep(3 * time.Second) // 确保协程有足够的时间完成//高并发例子FindPrime()//单线程noGoroutine()
}func FindPrime() {var num intvar n intn, _ = fmt.Scanf("%d", &num)fmt.Println(n, num)n = numif num > 32 { // 当num很大时，增大n（即goroutine的数量）却没有带来性能提升甚至导致耗时n = 32}// 对于num=1000000// n = 1, 即noGoroutine()，大约200ms~270ms// n = 2,大约150ms~250ms// n = 4，大约170ms~270ms// n = 8，大约>220ms// 对于num=10000000// n = 1, 即noGoroutine()，大约5s~6s// n = 2,大约2.7s~2.9s// n = 4，大约1.6s~2.0s// n = 8，大约1.8s~2s// n = 16（开始耗时增加）, 大约2.1s~2.2s// 对于num=100000000// n = 1, 即noGoroutine()，>100s// n = 4，大约40s~41s// n = 8，大约25s~26s// n = 16, 大约22s~24s// n = 32,大约·32s~33svar primeChan = make(chan int, num)var inChan = make(chan int, num)var exitChan = make(chan bool, n)var start = time.Now()go inPrime(num, inChan)for i := 0; i < n; i++ {go primeJudge(inChan, primeChan, exitChan)}go func() {for i := 0; i < n; i++ {<-exitChan}close(primeChan)}()for {_, ok := <-primeChanif !ok {break}//fmt.Println(res)}close(exitChan)fmt.Println(time.Since(start))
}func inPrime(num int, inChan chan int) {for i := 2; i < num; i++ {inChan <- i}close(inChan)
}func primeJudge(inChan chan int, primeChan chan int, exitChan chan bool) {var flag boolfor {v, ok := <-inChan//fmt.Println("v = ", v, "; ok = ", ok)if !ok {break}flag = truefor i := 2; i < int(math.Sqrt(float64(v))); i++ {if v%i == 0 {flag = falsebreak}}if flag {primeChan <- v}}exitChan <- true
}func noGoroutine() {var num intn, _ := fmt.Scanf("%d", &num)fmt.Println(n, num)var count = 0var start = time.Now()for i := 2; i <= num; i++ {var flag = truefor j := 2; j < (int)(math.Sqrt(float64(i))); j++ {if i%j == 0 {flag = falsebreak}if flag {count++}}}fmt.Println(time.Since(start))
}

    本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/24.html

    如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

    相关文章

    【51单片机】3-3【定时器/计数器/中断】超声波测距模块测距

    【51单片机】3-3【定时器/计数器/中断】超声波测距模块测距

    1.硬件 51最小系统超声波测距模块 2.软件 #include "reg52.h"//距离小于10cm,D5亮&#xff0c;D6灭&#xff0c;反之相反现象sbit D5 P3^7;//根据原理图&#xff08;电路图&#xff09;&#xff0c;设备变量led1指向P3组IO口的第7口 sbit D6 P3^6;//根据原理图&…
    阅读更多...
    2-Visual Studio 2022 NET开发Windows桌面软件并连接SQL Server数据库

    2-Visual Studio 2022 NET开发Windows桌面软件并连接SQL Server数据库

    引言 今天尝试Visual Studio 2022 NET开发一个NET桌面软件&#xff0c;并尝试连接SQL Server的数据库&#xff0c;此文章为开发笔记。 --------------------------------------------------------------------------------------------------------------------------------- …
    阅读更多...
    Kafka 漏消费和重复消费问题

    Kafka 漏消费和重复消费问题

    Kafka 虽然是一个高可靠、高吞吐的消息系统&#xff0c;但如果使用不当&#xff0c;**“漏消费”和“重复消费”**问题是非常容易发生的&#xff0c;尤其在业务系统中会造成数据丢失、重复写库等严重问题。 &#x1f3af; 一句话理解&#xff1a; Kafka 本身提供 “至多一次”…
    阅读更多...
    【大模型深度学习】如何估算大模型需要的显存

    【大模型深度学习】如何估算大模型需要的显存

    一、模型参数量 参数量的单位 参数量指的是模型中所有权重和偏置的数量总和。在大模型中&#xff0c;参数量的单位通常以“百万”&#xff08;M&#xff09;或“亿”&#xff08;B&#xff0c;也常说十亿&#xff09;来表示。 百万&#xff08;M&#xff09;&#xff1a;表示…
    阅读更多...
    LeetCode算法题(Go语言实现)_32

    LeetCode算法题(Go语言实现)_32

    题目 在一个大小为 n 且 n 为 偶数 的链表中&#xff0c;对于 0 < i < (n / 2) - 1 的 i &#xff0c;第 i 个节点&#xff08;下标从 0 开始&#xff09;的孪生节点为第 (n-1-i) 个节点 。 比方说&#xff0c;n 4 那么节点 0 是节点 3 的孪生节点&#xff0c;节点 1 是…
    阅读更多...
    Linux makefile的一些语法

    Linux makefile的一些语法

    一、定义变量 1. 变量的基本语法 在 makefile 中&#xff0c;变量的定义和使用非常类似于编程语言中的变量。变量的定义格式&#xff08;最好不要写空格&#xff09;如下&#xff1a; VARIABLE_NAMEvalue 或者 VARIABLE_NAME:value 表示延迟赋值&#xff0c;变量的值在引…
    阅读更多...
    CAN/FD CAN总线配置 最新详解 包含理论+实战（附带源码）

    CAN/FD CAN总线配置 最新详解 包含理论+实战（附带源码）

    看前须知&#xff1a;本篇文章不会说太多理论性的内容&#xff08;重点在理论结合实践&#xff09;&#xff0c;顾及实操&#xff0c;应用&#xff0c;一切理论内容支撑都是为了后续实际操作进行铺垫&#xff0c;重点在于读者可以看完文章应用。&#xff08;也为节约读者时间&a…
    阅读更多...
    木马学习记录

    木马学习记录

    一句话木马是什么 一句话木马就是仅需要一行代码的木马&#xff0c;很简短且简单&#xff0c;木马的函数将会执行我们发送的命令 如何发送命令&#xff06;发送的命令如何执行? 有三种方式&#xff1a;GET&#xff0c;POST&#xff0c;COOKIE&#xff0c;一句话木马中用$_G…
    阅读更多...
    Linux系统调用编程

    Linux系统调用编程

    一、进程和线程的概念 1.进程 进程是指一个具有独立功能的程序在某个数据集上的一次动态执行过程,它是系统进行资源分配和调度的最小单元。 定义&#xff1a;进程是程序的一次执行实例&#xff0c;拥有独立的地址空间、资源&#xff08;如内存、文件描述符等&#xff09;和系…
    阅读更多...
    PostgreSQL的扩展（extensions）-常用的扩展-pg_dirtyread

    PostgreSQL的扩展（extensions）-常用的扩展-pg_dirtyread

    PostgreSQL的扩展&#xff08;extensions&#xff09;-常用的扩展-pg_dirtyread pg_dirtyread 是 PostgreSQL 的一个特殊扩展&#xff0c;它允许读取已被删除但尚未被 VACUUM 清理的数据行&#xff0c;是数据恢复的重要工具。 原理&#xff1a; pg_dirtyread 通过直接访问表的…
    阅读更多...
    花卉识别分类系统,Python/resnet18/pytorch

    花卉识别分类系统,Python/resnet18/pytorch

    花卉识别分类系统,Python/resnet18/pytorch 基于pytorch训练, resnet18网络&#xff0c;可用于训练其他分类问题&#xff0c;也可自己重新训练 共五种花卉&#xff1a;雏菊&#xff0c;蒲公英&#xff0c;玫瑰&#xff0c;向日葵&#xff0c;郁金香 标价包含GUI源码、数据集…
    阅读更多...
    SQL Server数据库异常-[SqlException (0x80131904): 执行超时已过期] 操作超时问题及数据库日志已满的解决方案

    SQL Server数据库异常-[SqlException (0x80131904): 执行超时已过期] 操作超时问题及数据库日志已满的解决方案

    &#x1f9d1; 博主简介&#xff1a;CSDN博客专家、CSDN平台优质创作者&#xff0c;获得2024年博客之星荣誉证书&#xff0c;高级开发工程师&#xff0c;数学专业&#xff0c;拥有高级工程师证书&#xff1b;擅长C/C、C#等开发语言&#xff0c;熟悉Java常用开发技术&#xff0c…
    阅读更多...
    最新文章

    Copyright @ 2022~2023