分配内存之new

官方文档定义：

  1. // The new built-in function allocates memory. The first argument is a type,
  2. // not a value, and the value returned is a pointer to a newly
  3. // allocated zero value of that type.
  4. func new(Type) *Type

翻译出来就是：new是一个分配内存的内置函数，第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针。我们平常在使用指针的时候是需要分配内存空间的，未分配内存空间的指针直接使用会使程序崩溃，比如这样：

  1. var a *int64
  2. *a = 10

我们声明了一个指针变量，直接就去使用它，就会使用程序触发panic，因为现在这个指针变量a在内存中没有块地址属于它，就无法直接使用该指针变量，所以new函数的作用就出现了，通过new来分配一下内存，就没有问题了：

  1. var a *int64 = new(int64)
  2.  *a = 10

上面的例子，我们是针对普通类型int64进行new处理的，如果是复合类型，使用new会是什么样呢？来看一个示例：

  1. func main(){
  2.  // 数组
  3.  array := new([5]int64)
  4.  fmt.Printf("array: %p %#v \n", &array, array)// array: 0xc0000ae018 &[5]int64{0, 0, 0, 0, 0}
  5.  (*array)[0] = 1
  6.  fmt.Printf("array: %p %#v \n", &array, array)// array: 0xc0000ae018 &[5]int64{1, 0, 0, 0, 0}
  8.  // 切片
  9.  slice := new([]int64)
  10.  fmt.Printf("slice: %p %#v \n", &slice, slice) // slice: 0xc0000ae028 &[]int64(nil)
  11.  (*slice)[0] = 1
  12.  fmt.Printf("slice: %p %#v \n", &slice, slice) // panic: runtime error: index out of range [0] with length 0
  14.  // map
  15.  map1 := new(map[string]string)
  16.  fmt.Printf("map1: %p %#v \n", &map1, map1) // map1: 0xc00000e038 &map[string]string(nil)
  17.  (*map1)["key"] = "value"
  18.  fmt.Printf("map1: %p %#v \n", &map1, map1) // panic: assignment to entry in nil map
  20.  // channel
  21.  channel := new(chan string)
  22.  fmt.Printf("channel: %p %#v \n", &channel, channel) // channel: 0xc0000ae028 (*chan string)(0xc0000ae030) 
  23.  channel <- "123" // Invalid operation: channel <- "123" (send to non-chan type *chan string) 
  24. }

从运行结果可以看出，我们使用new函数分配内存后，只有数组在初始化后可以直接使用，slice、map、chan初始化后还是不能使用，会触发panic，这是因为slice、map、chan基本数据结构是一个struct，也就是说他里面的成员变量仍未进行初始化，所以他们初始化要使用make来进行，make会初始化他们的内部结构，我们下面一节细说。还是回到struct初始化的问题上，先看一个例子：

  1. type test struct {
  2.  A *int64
  3. }
  5. func main(){
  6.  t := new(test)
  7.  *t.A = 10  // panic: runtime error: invalid memory address or nil pointer dereference
  8.              // [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x10a89fd]
  9.  fmt.Println(t.A)
  10. }

从运行结果得出使用new()函数初始化结构体时，我们只是初始化了struct这个类型的，而它的成员变量是没有初始化的，所以初始化结构体不建议使用new函数，使用键值对进行初始化效果更佳。

其实 new 函数在日常工程代码中是比较少见的，因为它是可以被代替，使用T{}方式更加便捷方便。

初始化内置结构之make

在上一节我们说到了，make函数是专门支持 slice、map、channel 三种数据类型的内存创建，其官方定义如下：

  1. // The make built-in function allocates and initializes an object of type
  2. // slice, map, or chan (only). Like new, the first argument is a type, not a
  3. // value. Unlike new, make's return type is the same as the type of its
  4. // argument, not a pointer to it. The specification of the result depends on
  5. // the type:
  6. // Slice: The size specifies the length. The capacity of the slice is
  7. // equal to its length. A second integer argument may be provided to
  8. // specify a different capacity; it must be no smaller than the
  9. // length. For example, make([]int, 0, 10) allocates an underlying array
  10. // of size 10 and returns a slice of length 0 and capacity 10 that is
  11. // backed by this underlying array.
  12. // Map: An empty map is allocated with enough space to hold the
  13. // specified number of elements. The size may be omitted, in which case
  14. // a small starting size is allocated.
  15. // Channel: The channel's buffer is initialized with the specified
  16. // buffer capacity. If zero, or the size is omitted, the channel is
  17. // unbuffered.
  18. func make(t Type, size ...IntegerType) Type

大概翻译最上面一段：make内置函数分配并初始化一个slice、map或chan类型的对象。像new函数一样，第一个参数是类型，而不是值。与new不同，make的返回类型与其参数的类型相同，而不是指向它的指针。结果的取决于传入的类型。

使用make初始化传入的类型也是不同的，具体可以这样区分：

  1. Func             Type T     res
  2. make(T, n)       slice      slice of type T with length n and capacity n
  3. make(T, n, m)    slice      slice of type T with length n and capacity m
  5. make(T)          map        map of type T
  6. make(T, n)       map        map of type T with initial space for approximately n elements
  8. make(T)          channel    unbuffered channel of type T
  9. make(T, n)       channel    buffered channel of type T, buffer size n

不同的类型初始化可以使用不同的姿势，主要区别主要是长度（len）和容量（cap）的指定，有的类型是没有容量这一说法，因此自然也就无法指定。如果确定长度和容量大小，能很好节省内存空间。

写个简单的示例：

  1. func main(){
  2.  slice := make([]int64, 3, 5)
  3.  fmt.Println(slice) // [0 0 0]
  4.  map1 := make(map[int64]bool, 5)
  5.  fmt.Println(map1) // map[]
  6.  channel := make(chan int, 1)
  7.  fmt.Println(channel) // 0xc000066070
  8. }

这里有一个需要注意的点，就是slice在进行初始化时，默认会给零值，在开发中要注意这个问题，我就犯过这个错误，导致数据不一致。

new和make区别总结

  • new函数主要是为类型申请一片内存空间，返回执行内存的指针
  • make函数能够分配并初始化类型所需的内存空间和结构，返回复合类型的本身。
  • make函数仅支持 channel、map、slice 三种类型，其他类型不可以使用使用make。
  • new函数在日常开发中使用是比较少的，可以被替代。
  • make函数初始化slice会初始化零值，日常开发要注意这个问题。

make函数底层实现

我还是比较好奇make底层实现是怎样的，所以执行汇编指令：go tool compile -N -l -S file.go，我们可以看到make函数初始化slice、map、chan分别调用的是runtime.makeslice、runtime.makemap_small、runtime.makechan这三个方法，因为不同类型底层数据结构不同，所以初始化方式也不同，我们只看一下slice的内部实现就好了，其他的交给大家自己去看，其实都是大同小异的。

  1. func makeslice(et *_type, len, cap int) unsafe.Pointer {
  2.  mem, overflow := math.MulUintptr(et.size, uintptr(cap))
  3.  if overflow || mem > maxAlloc || len < 0 || len > cap {
  4.   // NOTE: Produce a 'len out of range' error instead of a
  5.   // 'cap out of range' error when someone does make([]T, bignumber).
  6.   // 'cap out of range' is true too, but since the cap is only being
  7.   // supplied implicitly, saying len is clearer.
  8.   // See golang.org/issue/4085.
  9.   mem, overflow := math.MulUintptr(et.size, uintptr(len))
  10.   if overflow || mem > maxAlloc || len < 0 {
  11.    panicmakeslicelen()
  12.   }
  13.   panicmakeslicecap()
  14.  }
  16.  return mallocgc(mem, et, true)
  17. }

这个函数功能其实也比较简单：

  • 检查切片占用的内存空间是否溢出。
  • 调用mallocgc在堆上申请一片连续的内存。

检查内存空间这里是根据切片容量进行计算的，根据当前切片元素的大小与切片容量的乘积得出当前内存空间的大小，检查溢出的条件有四个：

  • 内存空间大小溢出了
  • 申请的内存空间大于最大可分配的内存
  • 传入的len小于0，cap的大小只小于len

mallocgc函数实现比较复杂，我暂时还没有看懂，不过也不是很重要，大家有兴趣可以自行学习。

new函数底层实现

new函数底层主要是调用runtime.newobject：

  1. // implementation of new builtin
  2. // compiler (both frontend and SSA backend) knows the signature
  3. // of this function
  4. func newobject(typ *_type) unsafe.Pointer {
  5.  return mallocgc(typ.size, typ, true)
  6. }

内部实现就是直接调用mallocgc函数去堆上申请内存，返回值是指针类型。

总结

今天这篇文章我们主要介绍了make和new的使用场景、以及其不同之处，其实他们都是用来分配内存的，只不过make函数为slice、map、chan这三种类型服务。日常开发中使用make初始化slice时要注意零值问题，否则又是一个p0事故。