一文彻底理解Go语言栈内存/堆内存

Go 语言内存管理机制:深入剖析与多语言对比 内存管理在编程语言中至关重要,直接影响程序性能与稳定性。Go 语言凭借独特的内存管理机制在众多编程语言中脱颖而出。本文将深入解析 Go 语言内存管理机制,与 C/C++、Java、Python、PHP、Rust 等常见编程语言进行对比,阐述其优势,并结合实际项目应用场景给出代码示例,帮助读者全面理解 Go 语言内存管理的精妙之处。Go 语言的内存管理机制融合了高效的栈堆分配策略与先进的垃圾回收算法,与其他编程语言相比,在降低编程复杂度、提高内存利用效率和确保内存安全方面具有显著优势。 阅读详情

系列导读

本文基于64位平台、1Page=8KB、Go1.6

b3d9087e8ddf68dc10120587852d0451.png

本文为《Go语言轻松进阶》系列第二章「内存与垃圾回收」的第三小节。第二章目录:

查看本系列完整内容请访问

http://tigerb.cn/go/#/kernal/

本文导读


本文将从6个方向层层递进,帮助大家彻底理解Go语言的栈内存和堆内存:

  • 计算机为什么需要内存?

  • 为什么需要栈内存?

  • 为什么需要堆内存?

  • Go语言分配的是虚拟内存

  • Go语言栈内存的分配

    • 分配时机

    • 分配过程

  • Go语言堆内存的分配

    • 分配时机

    • 分配过程

计算机为什么需要内存?


计算机是运行自动化程序的载体,程序(或称之为进程)由可执行代码被执行后产生。那么计算机在运行程序的过程中为什么需要「内存」呢?为了轻松理解这个问题,我们先来简单看看:

  • 代码的本质

  • 可执行代码被执行后,程序的运行过程

代码的本质

简单来看代码主要包含两部分:

  • 指令部分:中央处理器CPU可执行的指令

  • 数据部分:常量等

代码包含了指令,代码被转化为可执行二进制文件,被执行后加载到内存中,中央处理器CPU通过内存获取指令,图示如下:

faf232b35ebd40f03f368efd5ecafbfd.png

详细请移步历史文章「回到本真,代码到底是什么?」

程序的运行过程

可执行代码文件被执行之后,代码中的待执行指令被加载到了内存当中。这时CPU就可以从内存中获取指令、并执行指令。

CPU执行指令简易过程分为三步:

  • 取指:CPU控制单元从内存中获取指令

  • 译指:CPU控制单元解析从内存中获取指令

  • 执行:CPU运算单元负责执行具体的指令操作

我们通过一个简易的时序图来看看CPU获取并执行指令的过程:

63a32a6c52b68240690276eba4e751b7.png

详细请移步历史文章「回到本真,代码是如何运行的?」

内存的作用

通过以上我们可以基本看出「内存」在计算机中扮演的角色:

  • 暂存二进制可执行代码文件中的指令、预置数据(常量)等

  • 暂存指令执行过程中的中间数据

  • 等等

至此我们基本明白了内存存在的意义。但是呢,我们又经常会听到关于「栈内存」、「堆内存」的概念,那「栈内存」和「堆内存」到底是什么呢?接下来我们继续来看看这个问题。

为什么需要栈内存?


程序在使用内存的过程中,不仅仅只需要关注内存的分配问题,还需要关注到内存使用完毕的回收问题,这就是内存管理中面临的最大两个问题:

  • 内存的分配

  • 内存的回收

有没有简单、高效、且通用的办法统一解决这个内存分配问题呢?

答:最简单、高效的分配和回收方式就是对一段连续内存的「线性分配」,「栈内存」的分配就采用了这种方式。

「栈内存」的简易管理过程:

1. 栈内存分配逻辑:current - alloc

66db7352d45f0bf28bc13e66717f54f1.png

2. 栈内存释放逻辑:current + alloc

6b16eefb59a5a1fc0584c67bde81396b.png

通过利用「栈内存」,CPU在执行指令过程中可以高效地存储临时变量。其次:

  • 栈内存的分配过程:看起来像不像数据结构「栈」的入栈过程。

  • 栈内存的释放过程:看起来像不像数据结构「栈」的出栈过程。

943b7ca18cb24b1301684a2ff04af795.png

所以同时你应该也理解了「为什么称之为栈内存?」。「栈内存」是计算机对连续内存的采取的「线性分配」管理方式,便于高效存储指令运行过程中的临时变量。

为什么需要堆内存?


假如函数A内变量是个指针且被函数B外的代码依赖,如果对应变量内存被回收,这个指针就成了野指针不安全。怎么解决这个问题呢?

答:这就是「堆内存」存在的意义,Go语言会在代码编译期间通过「逃逸分析」把分配在「栈」上的变量分配到「堆」上去。

51f5995b69e9e23b432bc49dc6d5699b.png

「堆内存」如何回收呢?

答:堆内存通过「垃圾回收器」回收,关于「垃圾回收器」后续我们详解。

Go语言分配的是虚拟内存


通过以上我们了解了「内存」、「栈内存」、「堆内存」存在的意义。除此之外,还有一个重要的知识点:程序和操作系统实际操作的都是虚拟内存,最终由CPU通过内存管理单元MMU(Memory Manage Unit)把虚拟内存的地址转化为实际的物理内存地址。图示如下:

ffe540d66eaeae4533e006c486139b2f.png

使用虚拟内存的原因:

  • 对于我们的进程而言,可使用的内存是连续的

  • 安全,防止了进程直接对物理内存的操作(如果进程可以直接操作物理内存,那么存在某个进程篡改其他进程数据的可能)

  • 提升物理内存的利用率,当进程真正要使用物理内存时再分配

  • 虚拟内存和物理内存是通过MMU(管理单元内存Memory Management Unit)映射的

所以,一个很重要的知识点:

结论:Go语言源代码对「栈内存」和「堆内存」的分配、释放等操作,都是对虚拟内存的操作,最终中央处理器CPU会统一通过MMU(管理单元内存Memory Management Unit)转化为实际的物理内存。

也就是说Go语言源代码中:

  • 「栈内存」的分配或释放都是对虚拟内存的操作

  • 「堆内存」的分配或释放都是对虚拟内存的操作

45d5d8ed1bf556307c34e4631f280b75.png

接着我们分别通过分配时机、分配过程两部分,来看看Go语言栈内存和堆内存的分配。

Go语言栈内存的分配


Go语言栈内存分配的时机

  1. 创建Goroutinue时

  • 1.1 创建g0

  • 1.2 创建g

栈扩容时

栈内存分配时机-创建Goroutinue时

创建g0函数代码片段:

// src/runtime/proc.go::1720
// 创建 m
func allocm(_p_ *p, fn func(), id int64) *m {
    // ...略
    if iscgo || mStackIsSystemAllocated() {
        mp.g0 = malg(-1)
 } else {
        // 创建g0 并申请8KB栈内存
        // 依赖的malg函数
        mp.g0 = malg(8192 * sys.StackGuardMultiplier)
 }
    // ...略
}

创建g函数代码片段:

// src/runtime/proc.go::3999
// 创建一个带有任务fn的goroutine
func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
    // ...略
    newg := gfget(_p_)
    if newg == nil {
      // 全局队列、本地队列找不到g 则 创建一个全新的goroutine
      // _StackMin = 2048
      // 申请2KB栈内存
      // 依赖的malg函数
      newg = malg(_StackMin)
      casgstatus(newg, _Gidle, _Gdead)
      allgadd(newg)
    }
    // ...略
}

以上都依赖malg函数代码片段,其作用是创建一个全新g:

// src/runtime/proc.go::3943
// 创建一个指定栈内存的g
func malg(stacksize int32) *g {
 newg := new(g)
 if stacksize >= 0 {
     // ...略
     systemstack(func() {
     // 分配栈内存
     newg.stack = stackalloc(uint32(stacksize))
  })
     // ...略
 }
 return newg
}

栈内存分配时机-栈扩容

// src/runtime/stack.go::838
func copystack(gp *g, newsize uintptr) {
 // ...略

 // 分配新的栈空间
 new := stackalloc(uint32(newsize))

    // ...略
}

结论:创建Goroutine和栈扩容时,栈内存的分配都是由函数stackalloc分配。

271e403b34d838f54ce6082d634a871e.png

所以,我们通过分析stackalloc函数就可以知道栈内存的分配过程了,具体如下。

栈内存分配过程

Go语言栈内存的分配按待分配的栈大小分为两大类:

  • 小于32KB的栈内存

  • 大于等于32KB的栈内存

小于32KB栈分配过程

1. 先去M线程缓存mcache的栈内存缓存stackcache中分配:

1d8b188a98237651d87ce7d913db8af6.png

2. 如果stackcache内存不足,则从全局栈内存缓存池stackpool中分配:

1b61c6fb849562fa493d3408216b848b.png

3. 如果stackpool内存不足,则从逻辑处理器结构p中的p.pagecache中分配:

87c288ef39a6c9350303e133cdef33b0.png

4. 如果p.pagecache内存不足,则从堆mheap中分配:

bad91d9d19c06eacc3ecbb086d3b7b46.png


大于等于32KB栈分配过程

1. 直接从全局栈内存缓存池stackLarge中分配:

898f08bd529663ce81d4fa743b395e0e.png

2. 全局栈内存缓存池stackLarge不足,则从逻辑处理器结构p中的p.pagecache中分配,如果p.pagecache则去堆上mheap分配:

558b32bd061b2300ddd3fb058a3561b3.png

Go语言堆内存的分配


想要更好的理解Go堆内存分配需要先了解Go的内存三层架构以及Go的内存管理单元mspan。历史文章请查看:

Go语言堆内存分配时机

判断一个变量是否应该分配到「堆内存」的关键点就是:代码编译阶段,编译器会通过逃逸分析判断并标记上该变量是否需要分配到堆上。

通常我们在创建如下变量时,变量都有可能被分配到堆上:

  • 切片Slice

    • 创建切片时

    • 切片扩容时

    • 拷贝切片时

  • 创建数组时

  • 创建Channel时

  • Map

    • 创建Map时

    • Map扩容时

  • 等等

涉及相关数据类型的写操作函数整理如下:

表格可左右滑动查看

类型名称描述代码位置
切片makeslice(et *_type, len, cap int) unsafe.Pointer创建切片src/runtime/slice.go::83
切片growslice(et *_type, old slice, cap int) slice切片扩容src/runtime/slice.go::125
切片makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointercopy切片src/runtime/slice.go::36
字节字符串gobytes(p *byte, n int) (b []byte)转换字符串string为[]byte类型src/runtime/string.go::301
字节字符串slicebytetostring(buf *tmpBuf, ptr *byte, n int) (str string)转换字节字符串[]byte为类型stringsrc/runtime/string.go::80
字节字符串rawstring(size int) (s string, b []byte)按大小初始化一个新的string类型src/runtime/string.go::83
字节字符串rawbyteslice(size int) (b []byte)按大小初始化一个新的[]byte类型src/runtime/string.go::83
字节字符串rawruneslice(size int) (b []rune)按大小初始化一个新的[]rune类型src/runtime/string.go::83
Channelmakechan(t *chantype, size int) *hchan创建一个chansrc/runtime/chan.go::71
数组func newarray(typ *_type, n int) unsafe.Pointer初始化一个数组src/runtime/malloc.go::1191
Mapmapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointermap申请内存src/runtime/map.go::571
Mapfunc (h *hmap) newoverflow(t *maptype, b *bmap) *bmapmap申请溢出桶src/runtime/map.go::245
等等......

这里我们以初始化切片的源代码为例来看看切片何时被分配到堆上的逻辑判断:

  • 理论上直接分配到栈内存上

  • 编译器进行逃逸分析,判断并标记该变量是否需要分配到堆上

    • 否:直接分配在栈上

    • 是:调用src/runtime/slice.go::makeslice()分配到堆上

切片分配过程源代码如下:

// 代码位置:src/cmd/compile/internal/gc/walk.go::1316
// 初始化切片
case OMAKESLICE:
    // ...略...
    // 逃逸标识,是否需要逃逸到堆上
    if n.Esc == EscNone {
        // ...略...

        // 不需要逃逸
        // 直接栈上分配内存
        t = types.NewArray(t.Elem(), i) // [r]T
        
        // ...略...
    } else {
        // 需要内存逃逸到堆上
        
        // ...略...

        // 默认使用makeslice64函数从堆上分配内存
        fnname := "makeslice64"
        argtype := types.Types[TINT64]

        // ...略...

        if (len.Type.IsKind(TIDEAL) || maxintval[len.Type.Etype].Cmp(maxintval[TUINT]) <= 0) &&
            (cap.Type.IsKind(TIDEAL) || maxintval[cap.Type.Etype].Cmp(maxintval[TUINT]) <= 0) {
            // 校验通过,则
            // 使用makeslice函数从堆上分配内存
            fnname = "makeslice"
            argtype = types.Types[TINT]
        }

        // ...略...

        // 调用上面指定的runtime函数
        m.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))

        // ...略...
    }

最终分配堆内存的地方都会依赖函数mallocgc,我们通过阅读mallocgc的代码就可以看到堆内存的分配过程。

20a915207d1b06c29ed06ed19477911b.png

Go语言堆内存分配过程

堆内存的分配按对象的大小分,主要分为三大类:

  • 微对象 0 < Micro Object < 16B

  • 小对象 16B =< Small Object <= 32KB

  • 大对象 32KB < Large Object

「微对象」和「小对象」通常通过逻辑处理器结构P的线程缓存mcache分配,「大对象」直接从堆上mheap中分配,如下图所示:

a083d88ee9f8cbce4c8e95b2a3e04393.png

  • 线程缓存mcache的tiny结构主要负责分配「微对象」

  • 线程缓存mcache的alloc结构主要负责分配「小对象」

9e5b7f591b3c98b1888da469a72528f6.png

微对象的分配过程

微对象 0 < Micro Object < 16B

1. 线程缓存mcache的tiny内存充足,则直接分配「微对象」所需内存,图示如下:

7c486de2e5d2bf3813463b065fd4702d.png

2. 线程缓存mcache的tiny内存不足,先去线程缓存mcache的alloc申请16B给tiny,再分配「微对象」所需内存,简易图示如下:

a7012987077bdec0ff586cec8f9f905a.png

申请16B详细过程图示如下:

b165b9e0d7958432c5055995e4518b68.png


小对象的分配过程

小对象 16B =< Small Object <= 32KB

1. 线程缓存mcache的alloc充足,则直接分配「小对象」所需内存,简易图示如下:

8c8dbe6e24d8a09ffb9707bf8e2a3150.png

详细分配过程图示如下:

6237a8bd3e0b26b168d43a150cb58812.png

2. 线程缓存mcache的alloc不足,则去中央缓存mcentral获取一个mspan,再分配「小对象」所需内存,图示如下:

745335df0cab2eb69ab95ab000bd6dc2.png

3. 线程缓存mcache的alloc不足,且中央缓存mcentral不足,则去逻辑处理器结构的pagecache分配,如果pagecache直接去堆上mheap获取一个mspan,再分配「小对象」所需内存,图示如下:

a66d2cb472e9c3c881efef4cdbd2cafa.png


大对象的分配过程

大对象 32KB < Large Object

1. 逻辑处理器结构的pagecache充足,则直接分配「大对象」所需内存,图示如下:

ee57b408b89f2091d37c640d39111572.png

2. 逻辑处理器结构的pagecache不足,则直接去堆上mheap分配「大对象」所需内存,图示如下:

76615cb347988db9c3bb5bd2c009ce65.png

总结


  • Go语言源代码中「栈内存」和「堆内存」的分配都是虚拟内存,最终CPU在执行指令过程中通过内部的MMU把虚拟内存转化为物理内存。

  • Go语言编译期间会进行逃逸分析,判断并标记变量是否需要分配到堆上,比如创建Map、Slice时。

  • 栈内存分配

    • 小于32KB的栈内存

      • 来源优先级1:线程缓存mcache

      • 来源优先级2:全局缓存stackpool

      • 来源优先级3:逻辑处理器结构p.pagecache

      • 来源优先级4:堆mheap

    • 大于等于32KB的栈内存

      • 来源优先级1:全局缓存stackLarge

      • 来源优先级2:逻辑处理器结构p.pagecache

      • 来源优先级3:堆mheap

  • 堆内存分配

    • 微对象 0 < Micro Object < 16B

      • 来源优先级1:线程缓存mcache.tiny

      • 来源优先级2:线程缓存mcache.alloc

    • 小对象 16B =< Small Object <= 32KB

      • 来源优先级1:线程缓存mcache.alloc

      • 来源优先级2:中央缓存mcentral

      • 来源优先级3:逻辑处理器结构p.pagecache

      • 来源优先级4:堆mheap

    • 大对象 32KB < Large Object

      • 来源优先级1:逻辑处理器结构p.pagecache

      • 来源优先级2:堆mheap

  • 「栈内存」也来源于堆mheap

6b090b998b848236d55493cf7828265f.png


Go轻松进阶系列 更多文章

7b4efdd8a5021b2b15e64e2213a0fd60.png

fd3140dd44437079f93bc2f076ad7672.gif

Go 语言的内存模型 本文详细解析了Go语言的内存模型,重点介绍了堆和栈的区别、逃逸分析机制及其优化方法。栈内存用于函数局部变量,具有快速分配特性;堆内存则用于全局变量和逃逸变量。通过逃逸分析,编译器决定变量分配位置以减少内存开销。文章还提供了三种优化策略:减少变量逃逸、使用sync.Pool复用对象以及利用pprof进行内存监控。掌握这些知识有助于编写高性能的Go程序,有效管理内存资源。 阅读详情

相关推荐

技术干货 | 理解 Go 内存分配

作者:rocketwang 如果你也是个 Go 开发者,你是否关心过内存的分配和回收呢?创建的对象究竟需要由 GC 进行回收,还是随着调用栈被弹出,就消失了呢? GC 导致的 Stop The World 是否导致了你程序的性能抖动呢? 本文简单介绍了 Go 的内存分配逻辑,介绍了 Go 内存划分模型。并以代码为例子,简要介绍了几种场景下 Go 内存分配逻辑。随后使用go build 命令验证了内存逃逸等相关验证。最后,总结出了内存分配原则。 需要关心内存分配问题 每个工程师的时间都如此宝贵,在

qq_42933419的博客 426

用golang开发系统软件的一些细节

()众所周知,golang非常适合用于开发后台应用,但也通常是各种各样的应用层软件。开发系统软件, 目前的首选还是C++, C, rust等语言。相比应用软件,系统软件需要更加稳定,更加高效。其维持自身运行的资源消耗要尽可能小,然后才可以把更多CPU、内存等资源用于业务处理上。简单来说,系统软件在CPU、内存、磁盘、带宽等计算机资源的使用上要做到平衡且极致。**golang代码经过写法上的优化,是可以达到接近C的性能的。

虚幻私塾 1391

FPGA实战:用Verilog实现Costas环载波同步(附Vivado2019.2仿真步骤)

本文详细介绍了如何在FPGA上使用Verilog实现Costas环载波同步,包括核心原理、Vivado2019.2工程配置、代码实现及仿真验证。通过正交下变频、相位误差检测和环路滤波等关键模块的设计,帮助开发者掌握数字通信系统中的载波同步技术,并提供了实用的调试和优化技巧。

k0l1m2n3o的博客 137

golang的堆内存结构

首先,golang的虚拟内存单元叫做heapArena,go每次申请的虚拟内存单元为64MB,最多能有2^20个内存单元 ,所有的heapArena组成了mheap(go的堆内存)。 简单结构如图: go的堆内存用的是分级分配机制,也就是将一个堆内存分成不同的等级,不同等级的堆内存所占空间不同,如下图: 它会分配合适的内存块给对象,如果有一个小的对象,那么就让他放进最小的空间而不能把他放到大的空间里,如果把他放到大的内存里,会影响到大内存块的效率

xiaodongdonga的博客 445

Proteus仿真实战:用AT89C51+L298N搭建直流电机PID调速系统(附完整工程文件)

本文详细介绍了使用Proteus仿真平台结合AT89C51单片机和L298N驱动模块搭建直流电机PID闭环调速系统的全过程。从硬件选型、电路连接到PID算法实现与参数整定,提供了完整的开发指南和工程文件,帮助读者快速掌握闭环调速系统的设计与调试技巧。

weixin_28724661的博客 449

避开内存陷阱:手把手教你用RKNN零拷贝接口正确管理输入输出Tensor

本文深入解析RKNN零拷贝接口在边缘计算中的高效内存管理策略,通过YOLOX实例演示如何避免内存对齐错误和数据错位。详细介绍了`rknn_tensor_mem`系列API的正确使用方法,包括内存创建、绑定、释放全流程,以及性能优化技巧如内存池技术和多核NPU负载均衡,帮助开发者提升推理效率并避开常见陷阱。

weixin_33686714的博客 160

go的堆内存结构分析

操作系统给应用提供的虚拟内存空间(在老的linux32位机器上,操作系统给每个进程一个4GB的虚拟空间),因为操作系统不允许进程动物理内存的,因为物理内存是多个进程共用的(动了别人的内存,那么其他进程可能就崩溃了),所以说操作系统给每个进程提供的是虚拟内存,然后操作系统管理虚拟内存到物理内存之间的关系。需要扫描和不需要扫描上面虚线部分,不是真正的内存,只是一个索引,它把下面的heapArena开辟的内存一组一组索引起来,简单来说它就是下面heapArena的目录。.....................

刘小雨的博客 2001

从零构建物联网监控系统:STM32+迪文屏+WiFi模组的实战解析

本文详细解析了基于STM32微控制器、迪文串口屏和WiFi模组构建物联网监控系统的完整方案。从硬件选型、系统架构设计到数据交互实现,提供了包括迪文屏GUI开发、STM32通信协议、低功耗优化等实战经验,帮助开发者快速掌握物联网监控系统的核心技术。

docker7nomad的博客 731

Go 内存管理,内存分配

Go 内存管理,内存分配

Go的全部 1858

Windows 必看!OpenClaw 一键安装教程|告别报错,一次成功不踩坑

OpenClaw 完整安装与配置的全流程教程

m0_70389289的博客 1086

机器学习的学习准则(期望风险最小化、经验风险最小化、结构风险最小化)

要评价模型f(x, θ)的好坏,可通过期望风险R(θ)来衡量:求期望损失R(θ)不仅需要知道损失函数还需要知道真实分布,损失函数可以通过一定的准则计算得到,但是样本空间的真实分布是未知的。所以不能直接求R(θ)。期望风险R(θ)无法计算,给定一个训练集D =,我们可以计算经验风险,经验风险就是在训练集上的平均损失:为了解决过拟合问题,引入了参数正则化来限制模型的能力。使其不要过度的最小化经验风险。这种准则就是结构风险最小化准则

... 2227

go中的堆和栈

我们定义的变量存放在堆还是栈中?一般是这么来分配的 堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵 栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 那么go中的全局变量和局部变量都是放在哪里呢? 1. 首先要搞清楚变量的生命周期 ...

weixin_40456226的博客 3298

(一)Tushare Pro教程:股票基本数据接口

 一直使用tushare作数据源,这里开个教程大家一起学习。 一、介绍        tushare是一个python股票数据源,现已升级到tushare pro版本,新版本在数据稳定性和获取速率上大幅提升。与wind、东财等收费数据源相比,tushare pro算是金融数据界的良心之作,其为从事金融工程、量化研究等方向的同学们提供了便利。tushare pro还有一点突出的特色就是已经将股票...

虎毛的博客 4万+

Golang原理剖析(彻底理解Go语言栈内存/堆内存、Go内存管理)

本文探讨了计算机内存的必要性及其管理机制。首先指出内存用于暂存可执行代码指令和中间数据,支持CPU执行指令的三步流程(取指、译指、执行)。接着分析栈内存采用线性分配方式实现高效临时变量存储,其分配释放类似数据结构栈的操作。堆内存则解决变量逃逸问题,通过垃圾回收器管理。最后说明Go语言操作的是虚拟内存,由MMU映射为物理内存,并详细描述了Go语言栈内存分配的时机(创建Goroutine和栈扩容)及实现过程。全文揭示了内存管理在程序执行中的核心作用。

Atticus的博客 662

Python航空航天设计神器!从入门到实操,小白也能搞定飞机优化

AeroSandbox的核心价值的是:​降低航空工程优化的门槛,用Python实现高效、简洁的工程设计​。无论是科研、学习还是实际项目,它都能帮你节省大量时间,不用再手动推导导数、编写复杂的优化逻辑。对于新手来说,建议先从案例1(Rosenbrock函数)入手,熟悉优化流程,再尝试案例2(翼型优化),逐步掌握核心用法;对于有航空相关需求的小伙伴,可以深入研究内置的物理模型,结合自己的项目进行定制化开发。最后,互动时间到!👉 你是用AeroSandbox做科研、练手还是实际项目?

源代码杀手的博客 129

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

go 栈内存和堆内存概念以及内存逃逸分析

为了让程序员更好地专注于业务代码的实现,Go 语言增加了垃圾回收机制,自动地回收不再使用的内存。Go 语言有两部分内存空间:栈内存和堆内存。 1. 栈内存 栈只允许往线性表的一端放入数据,之后在这一端取出数据,按照后进先出(LIFO, Last In First Out )的顺序,如图所示。 往栈中放入元素的过程叫做入栈。入栈会增加栈的元素数量,最后放入的元素总是位于栈的顶部,最先放入的元素总是位于栈的底部。 从栈中取出元素时,只能从栈顶部取出。取出元素后,栈的数量会变少。最先放入的元素总是最后被取出

Mark66890620 1399

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Go语言内存 Go内存 golang内存

1 为什么计算机需要内存 2 为什么栈内存 堆内存 3 为什么虚拟内存?如何分配栈内存 堆内存? 4 分配时机和分配过程?

yuezhilangniao的博客 396

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

【Go】Go语言的介绍

连续栈策略在协程的栈空间不足时,调用newstack创建一块为原来大小两倍的栈空间,然后调用copystack将原来空间中所有内容复制到新开辟的栈空间中,将指向旧栈对应变量的指针重新指向新栈(想同变量在栈扩容前后地址发生变化),最后调用stackfree销毁并回收原来的栈空间。1) 分段栈:Go1.13之前栈扩容使用分段栈策略,如果栈空间不足调用newstack创建一个新的栈空间,但是新创建的栈空间和原来的栈空间不连续,协程多个栈空间之间用双向链表的形式串联,通过指针找到这些栈空间。

小田的专栏 1085

Go内存逃逸分析:优化堆内存分配详解

Go语言的内存分配模型结合了编译期的静态分析和运行时的动态管理。尽可能在栈上分配,必要时才使用堆内存。mspan:最基本的内存管理单元mcache:每个P(处理器)的本地缓存mcentral:全局内存缓存这种分层设计最大限度减少了并发场景下的锁竞争,为Go的高性能并发提供了基础保障。简单来说,内存逃逸是指原本应该在栈上分配的变量,因为某些原因不得不在堆上分配的现象。就像一个本该在家吃饭的人,因为各种原因不得不去餐厅用餐一样。

sinat_27016095的博客 1046

Go内存管理一文足矣

编辑推荐:本文主要从内存分配角度来梳理个人对Go内存管理的理解, 希望对您的学习有所帮助。最早学习C、C++语言时,它们都是把内存的管理全部交给开发者,这种方式最灵活但是也最容易出问题,对人员要求极高;后来出现的一些高级语言像Java、JavaScript、C#、Go,都有语言自身解决了内存分配和回收问题,降低开发门槛,释放生产力。然而对于想要深入理解原理的同学来说却带来了负担,本篇文章主要从内存分配角度来梳理个人理解,后续文章中会介绍Go的垃圾回收机制。进程的内存空间程序文件段(.text),包括二进制可

Firstlucky77的博客 3039

我所理解的 Go 的 GC (Garbage Collection) 垃圾回收机制

Go 语言(Golang)作为一款内置运行时的现代编程语言,其垃圾回收(Garbage Collection, GC)机制是开发者理解其性能和行为的关键一环。要深入理解 Go 的 GC,我们首先需要明确垃圾回收的核心任务是什么,以及它在设计上需要面对哪些权衡与博弈。在主流的编程语言内存模型中,程序运行时使用到的内存通常可以划分为几个区域,其中最主要的是静态数据区、栈(stack)和堆(heap)。

sc35262的博客 946

Go 语言高性能最佳实践

在 Go 语言高性能实践中,合理使用栈内存可以显著减少堆分配,从而优化程序性能。通过避免变量逃逸、精简结构体使用、选择高效数据结构,并借助工具分析逃逸情况,可以有效降低垃圾回收压力,提升运行效率。这些优化方法简单而高效,是 Go 开发者不可忽视的关键技巧。 理解 Go 语言中的栈与堆 在 Go 语言中,栈内存分配速度快,主...

2023年最新地推相关信息 725

Golang 内存分配机制详解

Go 语言的内存分配机制是理解和优化 Go 程序性能的关键。在 Go 中,内存管理是自动进行的,这得益于 Go 的垃圾回收机制。了解内存如何分配和回收,可以帮助我们写出更高性能的代码。本文将深入讲解下 Go 内存分配机制。

路多辛的所思所想 1906

Golang中一些语言细节的理解

Golang值传递的时候,作为实参传入的就是SliceHeader结构体,前面说了是浅拷贝。就是值传入的内容只有SliceHeader中的Data指针、Len、Cap,Data指针所指向的那个数组是没有被复制的。也就是对于这个数组来说,**数组是被引用传递**的。

幸福的青鸟 513
上一篇: 回到本真,代码是如何运行的?
下一篇: 为什么需要k8s?
TIGERB_Blog
博客等级 码龄10年 109粉丝 65原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值