go关于string与[]byte再学深一点

目标：充分理解string与[]bytes零拷贝转换的实现

先回顾下string与[]byte的基本知识

1. string与[]byte的数据结构

reflect包中关于字符串的数据结构

// StringHeader is the runtime representation of a string.

type StringHeader struct {

   Data uintptr

   Len int

}

Data指向的是某个数组的首地址

len代表数组的长度。

uintptr是一种特殊指针，下文会具体介绍

说明

• string是一个8位的byte的集合，通常代表utf-8文本（但不一定都是）
• string可以为empty但不能是nil
• string的值是不能改变的（因为底层是数组）

reflect包中关于[]bytes的数据结构

type SliceHeader struct {

    Data uintptr

    Len int

    Cap int

}

Data指向的就是byte数组

[]byte是一个指向byte类型数组的slice

可以看到stringStruct与slice区别是cap，说明[]bytes的值是可变的，因为底层是切片。而string的值是不能改变的（因为底层是数组）

2. 基本数据结构的空间大小以及内存对齐

bl := true

fmt.Println("size of bool:", unsafe.Sizeof(bl))// 1

i := 10

fmt.Println("size of int:", unsafe.Sizeof(i)) // 8

i32 := int32(10)

fmt.Println("size of int32:", unsafe.Sizeof(i32)) // 4

i64 := int64(10)

fmt.Println("size of int64:", unsafe.Sizeof(i64)) // 8

str := "xxx"

fmt.Println("size of str:", unsafe.Sizeof(str)) // 16



type xstruct struct {

  a bool

  b int32

  c string

}

xx := xstruct{true, 10, "hello"}



fmt.Println("size of xx.a:", unsafe.Sizeof(xx.a)) // 1

fmt.Println("size of xx.b:", unsafe.Sizeof(xx.b)) // 4

fmt.Println("size of xx.c:", unsafe.Sizeof(xx.c)) // 16

fmt.Println("size of xx:", unsafe.Sizeof(xx)) // 不是1+4+16=21,而是24，为什么呢？由于字节对齐

// xx.a为一个字节，而实际存储时会占用一个"对齐系数"也就是8字节(对于64位机器，"对齐系数"是8字节)；

// xx.b为四个字节，所以1+4=5，放一个对齐系数(8字节)，其余剩余部分用0补充

// xx.c为16个字节，刚好放满2个对齐系数(16字节)。所以8+16=24字节

从代码中总结常见类型变量占用空间：

bool占1个字节

int32占4个字节

int与int64 占4字节(64位机器)

string占16个字节，其中包含2部分，第一部分unsafe.pointer占8字节，第二部分len int占8字节

struct结构体占用的空间，计算时需要考虑字节对齐,字节对齐的好处是减少cpu访问memory的此次，cpu读取memory最小单位是一个字长(8字节)，从而提供访问内存性能。(具体细节请问google)

3. unsafe.pointer与uintptr

string与[]byte结构的定义出现了uintptr，并且unsafe.pointer通常用于类型转换，下面具体介绍2中指针类型。

• unsafe.pointer与uintptr都是指针，但又不是普通指针，经查阅指针分为三种类型，分别有：

1. *类型: 这是最常用的指针，名叫普通指针类型，用于传递对象地址，不能进行指针运算。

2. unsafe.Pointer:通用指针类型，用于转换不同类型的指针，不能进行指针运算，不能读取内存存储的值（必须转换到某一类型的普通指针）。

3. uintptr:用于指针运算. 本质是存储 `指针地址` 的int类型

• unsafe.Pointer类型有四个重要描述：

（1）任何类型的指针都可以被转化为Pointer

（2）Pointer可以被转化为任何类型的指针

（3）uintptr可以被转化为Pointer

（4）Pointer可以被转化为uintptr

简而言之，unsafe.Pointer可以实现指针类型的转换，uintptr用于指针计算

下面看看Pointer的内部结构：

type Pointer *ArbitraryType


// ArbitraryType is here for the purposes of documentation only and is not actually

// part of the unsafe package. It represents the type of an arbitrary Go expression.

type ArbitraryType int

ArbitraryType是int的一个别名，在Go中对ArbitraryType赋予特殊的意义。代表一个任意Go表达式类型。

• unsafe.Pointer的使用示例：

value1 := int32(10)

value2 := int64(12)



p := &value1

fmt.Println(reflect.TypeOf(p)) // *int32

fmt.Println(*p) // 10



//p = &value2 // 错误。 无法将p指向&value2地址，因为p是*int32类型，&value2是*ini64类型

unsPtr := unsafe.Pointer(&value2) // 将*int64先转换为unsafe.Pointer类型指针，此时unsPtr指向&value2(也就是value2的地址)

p = (*int32)(unsPtr) //转换为*int32指针类型

fmt.Println(reflect.TypeOf(p)) // *int32

fmt.Println(*p) // 11

• uintptr的使用示例

type student struct {

name string

age uint8

}

s := student{

name: "tom", // string类型，16字节

age: 18, // int8类型，1字节

}



uptr := (uintptr)(unsafe.Pointer(&s)) // uptr指向结构体的首地址

uptr = uptr + 16 // uptr移动16字节，指向age的地址

age := *(*int8)(unsafe.Pointer(uptr)) // 转换为*int8类型的指针

fmt.Printf("age=%d\n", age) // 18

• 对uinitptr与unsafe.Pointer有简单了解后，再看结构体内存对齐示例

type student struct {

name string

age uint8

city string

}

s := student{

name: "tom", // string类型，16字节

age: 18, // int8类型，1字节； 需要做内存对齐，独占一个字长，本身占一个字节，其余7个字节填充

city: "shenzhen", // string类型，16字节

}

结构体的内存空间占用情况：

代码验证结构体占用空间的总大小，以及每个成员占用空间大小：

// 结构体占用空间

fmt.Println("size of s:", unsafe.Sizeof(s)) // 40


// 计算变量的地址

fmt.Printf("address of s.name: %p\n", &s.name) // 0xc00008c030--->转换为十进制824634294320

fmt.Printf("address of s.age: %p\n", &s.age) // 0xc00008c040--->转换为十进制824634294336

fmt.Printf("address of s.city: %p\n", &s.city) // 0xc00008c048--->转换为十进制824634294344


// 打印内部变量的相对字符串首地址的偏移量

fmt.Printf("offset of s.age:%d\n", unsafe.Offsetof(s.name)) // 0

fmt.Printf("offset of s.age:%d\n", unsafe.Offsetof(s.age)) // 16

fmt.Printf("offset of s.age:%d\n", unsafe.Offsetof(s.city)) // 24,计算方法是24=16+8

下面我们把s字符串再进一步"打开"，探索一下字符串内部

先将s字符串转换为*reflect.StringHeader, 并查看字符串内部Data,Len的值

x := (*reflect.StringHeader)(unsafe.Pointer(&s)) // 转换为*reflect.StringHeader

fmt.Printf("x.Data: %v\n", x.Data) // 17603737，这就是Data变量保存的具体值，其实是一个内存地址

fmt.Println("type of x.Data:", reflect.TypeOf(x.Data)) // uintptr

fmt.Printf("&x.Data: %p\n", &x.Data) // 0xc000100030

fmt.Printf("x.Len: %v\n", x.Len) // 3, 字符串"tom"的长度

fmt.Printf("&x.Len: %p\n", &x.Len) // 0xc000100038, 说明38-30=8，表示x.Data占8个字节

• 使用uintptr,计算出x.city的地址，再获取改地址的值

uptr := (uintptr)(unsafe.Pointer(&s)) // uptr指向结构体的首地址

uptr = uptr + 16 + 8 // uptr移动16+8字节，指向address的地址

city := *(*string)(unsafe.Pointer(uptr)) // 转换为*string类型的指针,再用*获取改地址的值，也就是x.city的值

fmt.Printf("city=%s\n", city) // shenzhen

4.string与[]bytes零拷贝的实现

最后，有了基础知识后，我们再看看string与[]bytes零拷贝的实现

string转换为[]byte

// 内存零拷贝方式类型转换
func stringtobyte(s string) []byte {
	// &s转换为*reflect.StringHeader
	var sptr *reflect.StringHeader
	sptr = (*reflect.StringHeader)(unsafe.Pointer(&s))

	var b []byte
	// &b转换为*reflect.SliceHeader
	bptr := (*reflect.SliceHeader)(unsafe.Pointer(&b))
	// 填充*reflect.SliceHeader内的Data,Len,Cap
	bptr.Data = sptr.Data
	bptr.Len = sptr.Len
	bptr.Cap = sptr.Len
	return b
}

为了编译理解，将转换过去用图示表示

[]byte转换为string

// 内存零拷贝方式类型转换
func bytetostring(b []byte) string {
	var bptr *reflect.SliceHeader
	bptr = (*reflect.SliceHeader)(unsafe.Pointer(&b))

	var s string
	sptr := (*reflect.StringHeader)(unsafe.Pointer(&s))
	sptr.Data = bptr.Data
	sptr.Len = bptr.Len

	return s
}

// 转换方法二

// 转换方法二
func String2Bytes(s string) []byte {
	sh := (*[2]uintptr)(unsafe.Pointer(&s))
	bh := [3]uintptr{sh[0], sh[1], sh[1]}
	return *(*[]byte)(unsafe.Pointer(&bh))
}

func String2Bytes2(s string) []byte {
	// &s转换为unsafe.Pointer类型的指针，再转换为指向定长为2的uintptr数组的指针
	sh := (*[3]uintptr)(unsafe.Pointer(&s))
	// sh是一个指针，不能直接转换为*[]byte的指针，先转换为unsafe.Pointer，再转换为*[]byte指针；最后*取出指针指向的内容
	return *(*[]byte)(unsafe.Pointer(sh))
}