1
2
3
4

type stringStruct struct {
	str unsafe.Pointer	//指向底层字节数组的指针
	len int				//字节长度
}

1
2
3
4

type StringHeader struct {
	Data uintptr
	Len  int
}

1
2
3
4
5

type slice struct {
	array unsafe.Pointer	//指向底层数组
	len   int 				//切片引用的底层数组的那部分的长度
	cap   int 				//底层数组的长度就是切片的容量
}

1

s := []int{3, 2, 1}

1
2
3
4
5
6

        0x000e 00014 (E:/golang/GOPATH/src/GoProgram/main.go:6) LEAQ    type:[3]int(SB), AX
        0x0015 00021 (E:/golang/GOPATH/src/GoProgram/main.go:6) PCDATA  $1, $0
        0x0015 00021 (E:/golang/GOPATH/src/GoProgram/main.go:6) CALL    runtime.newobject(SB)
        0x001a 00026 (E:/golang/GOPATH/src/GoProgram/main.go:6) MOVQ    $3, (AX)
        0x0021 00033 (E:/golang/GOPATH/src/GoProgram/main.go:6) MOVQ    $2, 8(AX)
        0x0029 00041 (E:/golang/GOPATH/src/GoProgram/main.go:6) MOVQ    $1, 16(AX)

1

s := make([]int)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func makeslice(et *_type, len, cap int) unsafe.Pointer {
	mem, overflow := math.MulUintptr(et.Size_, uintptr(cap))
	if overflow || mem > maxAlloc || len < 0 || len > cap {
		// NOTE: Produce a 'len out of range' error instead of a
		// 'cap out of range' error when someone does make([]T, bignumber).
		// 'cap out of range' is true too, but since the cap is only being
		// supplied implicitly, saying len is clearer.
		// See golang.org/issue/4085.
		mem, overflow := math.MulUintptr(et.Size_, uintptr(len))
		if overflow || mem > maxAlloc || len < 0 {
			panicmakeslicelen()
		}
		panicmakeslicecap()
	}

	return mallocgc(mem, et, true)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 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
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// A bucket for a Go map.
type bmap struct {
	// tophash generally contains the top byte of the hash value
	// for each key in this bucket. If tophash[0] < minTopHash,
	// tophash[0] is a bucket evacuation state instead.
	tophash [bucketCnt]uint8
	// Followed by bucketCnt keys and then bucketCnt elems.
	// NOTE: packing all the keys together and then all the elems together makes the
	// code a bit more complicated than alternating key/elem/key/elem/... but it allows
	// us to eliminate padding which would be needed for, e.g., map[int64]int8.
	// Followed by an overflow pointer.
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type mapextra struct {
	// If both key and elem do not contain pointers and are inline, then we mark bucket
	// type as containing no pointers. This avoids scanning such maps.
	// However, bmap.overflow is a pointer. In order to keep overflow buckets
	// alive, we store pointers to all overflow buckets in hmap.extra.overflow and hmap.extra.oldoverflow.
	// overflow and oldoverflow are only used if key and elem do not contain pointers.
	// overflow contains overflow buckets for hmap.buckets.
	// oldoverflow contains overflow buckets for hmap.oldbuckets.
	// The indirection allows to store a pointer to the slice in hiter.
	overflow    *[]*bmap
	oldoverflow *[]*bmap

	// nextOverflow holds a pointer to a free overflow bucket.
	nextOverflow *bmap
}

1

        0x0020 00032 (E:/golang/GOPATH/src/GoProgram/main.go:8) CALL    runtime.makemap(SB)

 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
28
29
30
31
32
33
34

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
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

type Map struct {
	mu Mutex						//互斥锁
	read atomic.Pointer[readOnly]	//存储readOnly结构体，其中包含m 和 amended字段
	dirty map[any]*entry			//原生的map
	misses int						//统计有多少次读取read没有命中
}
type readOnly struct {
	m       map[any]*entry			//原生的map
	amended bool 					// true if the dirty map contains some key not in m.
}
type entry struct {
	p atomic.Pointer[any]			
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type mapInterface interface {
	Load(any) (any, bool)
	Store(key, value any)
	LoadOrStore(key, value any) (actual any, loaded bool)
	LoadAndDelete(key any) (value any, loaded bool)
	Delete(any)
	Swap(key, value any) (previous any, loaded bool)
	CompareAndSwap(key, old, new any) (swapped bool)
	CompareAndDelete(key, old any) (deleted bool)
	Range(func(key, value any) (shouldContinue bool))
}

1
2
3
4

type iface struct {
	tab  *itab				//指向itab结构体，itab结构体中记录了接口类型信息和实现的方法
	data unsafe.Pointer		//指向底层真实数据
}

1
2
3
4
5
6
7

type itab struct {
	inter *interfacetype
	_type *_type
	hash  uint32 // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}

1

go build -gcflags -S main.go

1
2
3
4

type eface struct {
	_type *_type
	data  unsafe.Pointer
}

1
2
3

// nil is a predeclared identifier representing the zero value for a
// pointer, channel, func, interface, map, or slice type.
var nil Type // Type must be a pointer, channel, func, interface, map, or slice type