深入理解make和new，从底层到应用！

发表于 3年以前 | 总阅读数：414 次

上文说到超超总结了四种工作中常见的[内存逃逸场景] ，谈到内存逃逸就逃不掉Golang中申请内存空间的俩个关键字make和new。工作中每天都会用到这俩个关键字，但是说到俩者之间区别与联系，不知道小伙伴们是否知道呢？听说超超看过这俩个关键字的源码，下面来看看超超是如何理解的吧！

new的使用

面试官：new你应该常用吧，来看看下面这段代码运行结果是什么？

1package main
 2
 3import "fmt"
 4
 5//定义一个结构体，age字段为指针
 6type Student struct {
 7    age *int
 8}
 9
10//获取结构体对象指针
11func getStudent() *Student {
12    s := new(Student)
13    return s
14}
15
16func main() {
17    s := getStudent()
18    *(s.age) = 10
19    fmt.Println(s.age)
20}

考点：new的易错点

超超：这在运行时会发生panic，首先看一下关键字new的函数声明

1func new(Type) *Type

Type是指变量的类型，可以看到new会根据变量类型返回一个指向该类型的指针。

执行指令go build -gcflags="-l -S -N " main.go（：这里把整个汇编都贴出来帮大家复习下

 1"".getStudent STEXT size=86 args=0x8 locals=0x20
 2        //getStudent函数栈帧大小为32字节，参数为8字节
 3        0x0000 00000 (/main.go:9)  TEXT    "".getStudent(SB), ABIInternal, $32-8    
 4        //开辟函数栈空间
 5        0x0000 00000 (/main.go:9)  MOVQ    (TLS), CX
 6        0x0009 00009 (/main.go:9)  CMPQ    SP, 16(CX)
 7        0x000d 00013 (/main.go:9)  PCDATA  $0, $-2
 8        0x000d 00013 (/main.go:9)  JLS     79
 9        0x000f 00015 (/main.go:9)  PCDATA  $0, $-1
10        0x000f 00015 (/main.go:9)  SUBQ    $32, SP
11        0x0013 00019 (/main.go:9)  MOVQ    BP, 24(SP)
12        0x0018 00024 (/main.go:9)  LEAQ    24(SP), BP
13        0x001d 00029 (/main.go:9)  FUNCDATA        $0, gclocals·2a5305abe05176240e61b8620e19a815(SB)
14        0x001d 00029 (/main.go:9)  FUNCDATA        $1, gclocals·2a5305abe05176240e61b8620e19a815(SB)
15        //给返回值赋初值为0（变量+偏移量表示方法是伪寄存器）
16        0x001d 00029 (/main.go:9)  MOVQ    $0, "".~r0+40(SP)    
17        //将变量类型放入AX寄存器
18        0x0026 00038 (/main.go:10) LEAQ    type."".Student(SB), AX
19        //将变量类型放入栈顶
20        0x002d 00045 (/main.go:10) MOVQ    AX, (SP)
21        //调用runtime.newobject
22        0x0031 00049 (/main.go:10) PCDATA  $1, $0
23        0x0031 00049 (/main.go:10) CALL    runtime.newobject(SB)
24        //将返回的指针放入AX寄存器
25        0x0036 00054 (/main.go:10) MOVQ    8(SP), AX
26        //将AX寄存器中指针赋给指针s
27        0x003b 00059 (/main.go:10) MOVQ    AX, "".s+16(SP)
28        //AX寄存器中指针赋值给返回值
29        0x0040 00064 (/main.go:11) MOVQ    AX, "".~r0+40(SP)
30        0x0045 00069 (/main.go:11) MOVQ    24(SP), BP
31        0x004a 00074 (/main.go:11) ADDQ    $32, SP
32        0x004e 00078 (/main.go:11) RET

可以看到new底层调用的是runtime.newobject申请内存空间

1func newobject(typ *_type) unsafe.Pointer {
2    return mallocgc(typ.size, typ, true)
3}

newobject的底层调用mallocgc在堆上按照typ.size的大小申请内存，因此new只会为结构体Student申请一片内存空间，不会为结构体中的指针age申请内存空间，所以第10行的解引用操作就因为访问无效的内存空间而出现panic。

对于结构体指针，工作中一般使用s:=&Stuent{age:=new(int)}的方式赋值，这样能够清晰的知道结构体中的每一个字段是什么，避免不必要的错误！

make底层

面试官：那你再看看下面这段代码。

1package main
2
3import "fmt"
4
5func main() {
6    nums := new([]int)
7    (*nums)[0] = 1
8    fmt.Println((*nums)[0])
9}

考点：new的底层实现

超超：程序在运行时也会出现panic，先看一下slice的底层实现

1type slice struct {
2    array unsafe.Pointer    //指向用于存储切片数据的指针
3    len   int
4    cap   int
5}

这就和上面的例子一样了，new只会为结构体slice申请内存，而不会为当中的array字段申请内存，因此用(*nums)[0]取指会发生panic。

如果需要对slice、map、channel进行内存申请，则必须使用make申请内存，下面看一下make函数声明

1func make(t Type, size ...IntegerType) Type
2

可以看到make返回的是复合类型本身，将错误代码修改如下

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    //为了让make在堆上申请内存，这里将容量写大一点
 7    nums := make([]int, 8192)
 8    nums[0] = 1
 9    fmt.Println(nums[0], nums[1])
10}

执行指令go build -gcflags="-l -S -N " main.go（这里只截取make相关

 1...
 2        0x002f 00047 (main.go:7)     LEAQ    type.int(SB), AX
 3        0x0036 00054 (main.go:7)     MOVQ    AX, (SP)
 4        0x003a 00058 (main.go:7)     MOVQ    $8192, 8(SP)
 5        0x0043 00067 (main.go:7)     MOVQ    $8192, 16(SP)
 6        0x004c 00076 (main.go:7)     PCDATA  $1, $0
 7        0x004c 00076 (main.go:7)     CALL    runtime.makeslice(SB)
 8        0x0051 00081 (main.go:7)     MOVQ    24(SP), AX
 9        0x0056 00086 (main.go:7)     MOVQ    AX, "".nums+88(SP)
10        0x005b 00091 (main.go:7)     MOVQ    $8192, "".nums+96(SP)
11        0x0064 00100 (main.go:7)     MOVQ    $8192, "".nums+104(SP)
12....

可以看到make在申请slice内存时，底层调用的是runtime.makeslice

1func makeslice(et *_type, len, cap int) unsafe.Pointer {
 2    mem, overflow := math.MulUintptr(et.size, uintptr(cap))
 3    //做合法检查
 4    if overflow || mem > maxAlloc || len < 0 || len > cap {
 5        mem, overflow := math.MulUintptr(et.size, uintptr(len))
 6        if overflow || mem > maxAlloc || len < 0 {
 7            panicmakeslicelen()
 8        }
 9        panicmakeslicecap()
10    }
11      //做内存申请
12    return mallocgc(mem, et, true)
13}

可以看到makeslice申请内存底层调用的也是mallocgc，从这点看和new一样，但是细看new中mallocgc第一个参数（申请内存大小）用的是type.size，而make中的mallocgc第一个参数是mem，从MulUintptr源码中可以看出mem是slice的容量cap乘以type.size，因此使用makeslice可以成功的为切片申请内存。

1func MulUintptr(a, b uintptr) (uintptr, bool) {
2    if a|b < 1<<(4*sys.PtrSize) || a == 0 {
3        return a * b, false
4    }
5    overflow := b > MaxUintptr/a
6    return a * b, overflow
7}

make为map和channel申请内存底层分别是runtime.makemap_small，runtime.makechan，也是同样调用mallocgc，这里就不继续讨论了。