Go语言中的make和new

关于Go语言中make和new的区别，已经在网上看到了很多文档，但是总觉得缺点什么，所以今天就自己写一篇文章来讲一下。

首先先说下网上说的关于make和new的区别，大致有以下几点：

• make只能用于slice、map、channel的初始化，返回的是这三个类型本身。
• new用于为任何类型分配内存，并返回指向该类型的指针。
• new和make都能用于分配内存，但是make会初始化内存，而new不会。

make

make用于创建slice、map、channel，返回的是这三个类型本身。

有一个很普遍的说法：slice、map、channel是引用类型。也有人说，go语言中没有引用类型 。我们今天不争论这个，因为这只是概念上的问题，争论这个意义不大。

不过，Go官方的代码提交记录中，的确是在2013年就删除了对引用类型的支持。 而之所以能很多人还在说slice、map、channel、function、interface是引用类型，是因为这几种类型的实现中，有指针指向底层数据，比如slice， 在slice的实现中，有指针指向底层数组：

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

如果用这个标准来判断，那么string也是引用类型，因为string的实现中，也有指针指向底层数据：

type StringHeader struct {
 Data uintptr
 Len  int
}

slice, map, channel的区别

来看一个有趣的例子：

package main

import (
 "fmt"
 "unsafe"
)

func main() {
 arr := make([]int, 4, 8)
 maps := make(map[string]string, 10)
 chans := make(chan int, 10)

 arr[0] = 1
 arr[1] = 2

 maps["a"] = "a"

 chans <- 1

 fmt.Println("sizeof slice:", unsafe.Sizeof(arr))
 fmt.Println("sizeof map:", unsafe.Sizeof(maps))
 fmt.Println("sizeof chan:", unsafe.Sizeof(chans))
}

运行结果： 可以看到，slice的大小是24字节，这个很好理解，因为slice的实现中，有指针指向底层数组，所以slice的大小是指针的大小（8字节）+ len（8字节）+ cap（8字节）。 而为什么map和chan的大小是8字节呢？是因为其底层结构体的大小都是8字节？ 不是，map的底层对应的结构体是hmap，而chan的底层对应的结构体是hchan，其大小都远远超过了8字节：

map的底层结构体hmap

// A header for a Go map.
type hmap struct {
 // Note: the format of the hmap is also encoded in cmd/compile/internal/reflectdata/reflect.go.
 // Make sure this stays in sync with the compiler's definition.
 count     int // # live cells == size of map.  Must be first (used by len() builtin)
 flags     uint8
 B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
 noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
 hash0     uint32 // hash seed

 buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
 oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
 nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)

 extra *mapextra // optional fields
}

chan的底层结构体hchan

type hchan struct {
 qcount   uint           // total data in the queue
 dataqsiz uint           // size of the circular queue
 buf      unsafe.Pointer // points to an array of dataqsiz elements
 elemsize uint16
 closed   uint32
 elemtype *_type // element type
 sendx    uint   // send index
 recvx    uint   // receive index
 recvq    waitq  // list of recv waiters
 sendq    waitq  // list of send waiters

 // lock protects all fields in hchan, as well as several
 // fields in sudogs blocked on this channel.
 //
 // Do not change another G's status while holding this lock
 // (in particular, do not ready a G), as this can deadlock
 // with stack shrinking.
 lock mutex
}

那为什么make出来的chan和map是8字节呢？而8字节，正好是指针的大小。 我们来看一下示例代码的汇编：

go build -gcflags -S ./main.go

运行结果： 可以看到，使用make创建map和chan时，分别调用了runtime.makemap和runtime.makechan，这两个函数的返回值都是指针，所以make出来的map和chan的大小都是8字节。

runtime.makemap

// makemap implements Go map creation for make(map[k]v, hint).
// If the compiler has determined that the map or the first bucket
// can be created on the stack, h and/or bucket may be non-nil.
// If h != nil, the map can be created directly in h.
// If h.buckets != nil, bucket pointed to can be used as the first bucket.
func makemap(t *maptype, hint int, h *hmap) *hmap {
 mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
 if overflow || mem > maxAlloc {
  hint = 0
 }

 // initialize Hmap
 if h == nil {
  h = new(hmap)
 }
 h.hash0 = fastrand()

 // Find the size parameter B which will hold the requested # of elements.
 // For hint < 0 overLoadFactor returns false since hint < bucketCnt.
 B := uint8(0)
 for overLoadFactor(hint, B) {
  B++
 }
 h.B = B

 // allocate initial hash table
 // if B == 0, the buckets field is allocated lazily later (in mapassign)
 // If hint is large zeroing this memory could take a while.
 if h.B != 0 {
  var nextOverflow *bmap
  h.buckets, nextOverflow = makeBucketArray(t, h.B, nil)
  if nextOverflow != nil {
   h.extra = new(mapextra)
   h.extra.nextOverflow = nextOverflow
  }
 }

 return h
}

runtime.makechan

func makechan(t *chantype, size int) *hchan {
 elem := t.elem

 // compiler checks this but be safe.
 if elem.size >= 1<<16 {
  throw("makechan: invalid channel element type")
 }
 if hchanSize%maxAlign != 0 || elem.align > maxAlign {
  throw("makechan: bad alignment")
 }

 mem, overflow := math.MulUintptr(elem.size, uintptr(size))
 if overflow || mem > maxAlloc-hchanSize || size < 0 {
  panic(plainError("makechan: size out of range"))
 }

 // Hchan does not contain pointers interesting for GC when elements stored in buf do not contain pointers.
 // buf points into the same allocation, elemtype is persistent.
 // SudoG's are referenced from their owning thread so they can't be collected.
 // TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
 var c *hchan
 switch {
 case mem == 0:
  // Queue or element size is zero.
  c = (*hchan)(mallocgc(hchanSize, nil, true))
  // Race detector uses this location for synchronization.
  c.buf = c.raceaddr()
 case elem.ptrdata == 0:
  // Elements do not contain pointers.
  // Allocate hchan and buf in one call.
  c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
  c.buf = add(unsafe.Pointer(c), hchanSize)
 default:
  // Elements contain pointers.
  c = new(hchan)
  c.buf = mallocgc(mem, elem, true)
 }

 c.elemsize = uint16(elem.size)
 c.elemtype = elem
 c.dataqsiz = uint(size)
 lockInit(&c.lock, lockRankHchan)

 if debugChan {
  print("makechan: chan=", c, "; elemsize=", elem.size, "; dataqsiz=", size, "\n")
 }
 return c
}

slice和map用作函数参数时的区别

下面来看两个小例子：

slice作为函数参数

package slicedemo

import (
 "fmt"
 "testing"
)

func changeSlice0(arr []int) {
 arr[0] = 100
 fmt.Printf("changeSlice0 length: %d, cap: %d\n", len(arr), cap(arr))
}

func changeSlice1(arr []int) {
 arr = append(arr, 101, 102, 103, 104, 105, 106, 107, 108)
}

func TestSlice0(t *testing.T) {
 arr := make([]int, 5, 10)
 arr[0] = 1
 arr[1] = 2
 arr[2] = 3
 arr[3] = 4
 arr[4] = 5

 fmt.Printf("TestSlice1 length: %d, cap: %d\n", len(arr), cap(arr))
 changeSlice0(arr[1:])
 fmt.Printf("arr: %v\n", arr)
}

func TestSlice1(t *testing.T) {
 arr := make([]int, 1, 1)
 arr[0] = 1
 changeSlice1(arr)
 fmt.Printf("arr: %v\n", arr)
}

map作为函数参数

package mapdemo

import "testing"

func changeMap0(m map[string]int) {
 m["a"] = 1
 m["b"] = 2
 m["c"] = 3
 m["d"] = 4
 m["e"] = 5
 m["f"] = 6
 m["g"] = 7
 m["h"] = 8
 m["i"] = 9
 m["j"] = 10
 m["k"] = 11
 m["l"] = 12
 m["m"] = 13
 m["n"] = 14
 m["o"] = 15
 m["p"] = 16
}

func TestChangeMap(t *testing.T) {
 m := make(map[string]int)
 changeMap0(m)

 t.Log(m)
}

在go语言中，只有值传递，没有引用传递。使用slice和map作为函数参数时，传递的是slice和map的拷贝。而通过上面的讲解我们知道：slice本身是结构体，而 map本身是指针。 所以，当我们传递slice时，是把slice成员变量的值赋给了形参（也就是slice的拷贝），包含底层数组指针、长度值、容量值，如果我们在函数中 修改了slice的成员变量，那实际上是修改了slice的拷贝，而不是原来的slice。只不过，如果slice没有发生扩容，那么slice底层还是指向原来的数组，所以在 函数内部修改slice某个元素的值，会影响到原来的slice。但是，如果slice发生了扩容，那么slice底层指向的就是一个新的数组，所以在函数内部修改slice某 个元素的值，不会影响到原来的slice。 而当传递map时，是把hmap结构体的指针赋给了形参，所以在函数内部修改map，会影响到原来的map。

new

new用于为任何类型分配内存，并返回指向该类型的指针。 使用new来创建map、slice和channel时，并不会初始化内部的数据结构。

• 对于slice，返回的是一个指向底层结构体的指针,该结构体的成员变量都是零值。
• 对于map和chan来说，返回的是一个指向指针的指针，由于没有初始化， 其指向的就是一个nil指针。

new创建的map和chan是无法直接使用的。

本文由 mdnice 多平台发布