关于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 多平台发布