Golang make & new

当我们想要在 Go 语言中初始化一个结构时，可能会用到两个不同的关键字 — make 和 new。因为它们的功能相似，但是两者能够初始化的变量却有较大的不同。

  • make 的作用是初始化内置的数据结构，也就是slice、hash和 channel；
  • new 的作用是根据传入的类型分配一片内存空间并返回指向这片内存空间的指针；

在代码中往往都会使用如下所示的语句初始化这三类基本类型，这三个语句分别返回了不同类型的数据结构：

1
2
3
slice := make([]int, 0, 100)
hash := make(map[int]bool, 10)
ch := make(chan int, 5)
  1. slice 是一个包含 data、cap 和 len 的结构体 reflect.SliceHeader；
  2. hash 是一个指向 runtime.hmap 结构体的指针；
  3. ch 是一个指向 runtime.hchan 结构体的指针；

相比与复杂的 make 关键字，new 的功能就简单多了，它只能接收类型作为参数然后返回一个指向该类型的指针：

1
2
3
4
5
i := new(int)

var v int
i := &v
// 上述代码片段中的两种不同初始化方法是等价的，它们都会创建一个指向 `int` 零值的指针。

make

在编译期间的类型检查阶段，Go 语言会将代表 make 关键字的 OMAKE 节点根据参数类型的不同转换成了 OMAKESLICE、OMAKEMAP 和 OMAKECHAN 三种不同类型的节点，这些节点会调用不同的运行时函数来初始化相应的数据结构。

new

编译器会在中间代码生成阶段通过以下两个函数处理该关键字：

  1. cmd/compile/internal/gc.callnew 会将关键字转换成 ONEWOBJ 类型的节点；
  2. cmd/compile/internal/gc.state.expr 会根据申请空间的大小分两种情况处理：
    1. 如果申请的空间为 0，就会返回一个表示空指针的 zerobase 变量；
    2. 在遇到其他情况时会将关键字转换成 runtime.newobject 函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func callnew(t *types.Type) *Node {
    ...
    n := nod(ONEWOBJ, typename(t), nil)
    ...
    return n
}

func (s *state) expr(n *Node) *ssa.Value {
    switch n.Op {
    case ONEWOBJ:
        if n.Type.Elem().Size() == 0 {
            return s.newValue1A(ssa.OpAddr, n.Type, zerobaseSym, s.sb)
        }
        typ := s.expr(n.Left)
        vv := s.rtcall(newobject, true, []*types.Type{n.Type}, typ)
        return vv[0]
    }
}

需要注意的是，无论是直接使用 new，还是使用 var 初始化变量，它们在编译器看来都是 ONEW 和 ODCL 节点。如果变量会逃逸到堆上，这些节点在这一阶段都会被cmd/compile/internal/gc.walkstmt 转换成通过 runtime.newobject 函数并在堆上申请内存：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
func walkstmt(n *Node) *Node {
    switch n.Op {
    case ODCL:
        v := n.Left
        if v.Class() == PAUTOHEAP {
            if prealloc[v] == nil {
                prealloc[v] = callnew(v.Type)
            }
            nn := nod(OAS, v.Name.Param.Heapaddr, prealloc[v])
            nn.SetColas(true)
            nn = typecheck(nn, ctxStmt)
            return walkstmt(nn)
        }
    case ONEW:
        if n.Esc == EscNone {
            r := temp(n.Type.Elem())
            r = nod(OAS, r, nil)
            r = typecheck(r, ctxStmt)
            init.Append(r)
            r = nod(OADDR, r.Left, nil)
            r = typecheck(r, ctxExpr)
            n = r
        } else {
            n = callnew(n.Type.Elem())
        }
    }
}

不过这也不是绝对的，如果通过 var 或者 new 创建的变量不需要在当前作用域外生存，例如不用作为返回值返回给调用方，那么就不需要初始化在堆上。

runtime.newobject 函数会获取传入类型占用空间的大小，调用 runtime.mallocgc 在堆上申请一片内存空间并返回指向这片内存空间的指针：

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