十年网站开发经验 + 多家企业客户 + 靠谱的建站团队
量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决
1、 string的定义
公司主营业务:成都做网站、成都网站建设、成都外贸网站建设、移动网站开发等业务。帮助企业客户真正实现互联网宣传,提高企业的竞争能力。创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化,感谢他们对我们的高要求,感谢他们从不同领域给我们带来的挑战,让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。创新互联推出龙南免费做网站回馈大家。
Golang中的string的定义在reflect包下的value.go中,定义如下:
StringHeader 是字符串的运行时表示,其中包含了两个字段,分别是指向数据数组的指针和数组的长度。
// StringHeader is the runtime representation of a string.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type StringHeader struct {
Data uintptr
Len int
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
2、string不可变
Golang中的字符串是不可变的,不能通过索引下标的方式修改字符串中的数据:
在这里插入图片描述
运行代码,可以看到编译器报错,string是不可变的
在这里插入图片描述
但是能不能进行一些骚操作来改变元素的值呢?
package main
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
a := "hello,world"
b := a[6:]
bptr := (*reflect.StringHeader) (unsafe.Pointer(b))
fmt.Println(a)
fmt.Println(b)
*(*byte)(unsafe.Pointer(bptr.Data)) = '.'
fmt.Println(a)
fmt.Println(b)
}
// 运行结果
hello,world
world
unexpected fault address 0x49d7e3
fatal error: fault
[signal 0xc0000005 code=0x1 addr=0x49d7e3 pc=0x4779fa]
goroutine 1 [running]:
runtime.throw(0x49c948, 0x5)
C:/Program Files/Go/src/runtime/panic.go:1117 +0x79 fp=0xc0000dbe90 sp=0xc0000dbe60 pc=0x405fd9
runtime.sigpanic()
C:/Program Files/Go/src/runtime/signal_windows.go:245 +0x2d6 fp=0xc0000dbee8 sp=0xc0000dbe90 pc=0x4189f6
main.main()
F:/go_workspace/src/code/string_test/main.go:20 +0x13a fp=0xc0000dbf88 sp=0xc0000dbee8 pc=0x4779fa
runtime.main()
C:/Program Files/Go/src/runtime/proc.go:225 +0x256 fp=0xc0000dbfe0 sp=0xc0000dbf88 pc=0x4087f6
runtime.goexit()
C:/Program Files/Go/src/runtime/asm_amd64.s:1371 +0x1 fp=0xc0000dbfe8 sp=0xc0000dbfe0 pc=0x435da1
Process finished with the exit code 2
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
35
36
37
38
39
40
41
42
43
44
45
46
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
35
36
37
38
39
40
41
42
43
44
45
46
在上面的代码中,因为在go语言中不能进行指针的加减运算,因此取切片,让b的Data指针指向’,'所在的位置。然后把"hello,world"中的逗号改为点,但是发现还是不行,程序直接崩溃了。看来go语言中的指针得到了大大的限制,设计者并不想让程序员过度使用指针来写出一些不安全的代码。
3、使用string给另一个string赋值
Golang中的字符串的赋值并不是拷贝底层的字符串数组,而是数组指针和长度字段的拷贝。例如:当我们定义了一个字符串 a := “hello,world” 然后定义了 b := a 底层所做的操作只是创建了两个StringHeader的结构体,它们的Data字段都指向同一段数据,如下图:
在这里插入图片描述
我们可以利用代码来证实这一点:
package main
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
a := "hello,world"
b := a
fmt.Println(a)
fmt.Println(b)
aptr := (*reflect.StringHeader) (unsafe.Pointer(a))
bptr := (*reflect.StringHeader) (unsafe.Pointer(b))
fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))
}
// 运行结果
hello, world
hello, world
a ptr: 0x6bdb76
b ptr: 0x6bdb76
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
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
在上面的代码中,将a和b转换为StringHeader类型的指针,然后分别打印出,a和b的Data指针的值,发现是相同的
那么如果对a做切片赋值给b呢?
func main() {
a := "hello,world"
b := a[6:]
fmt.Println(a)
fmt.Println(b)
aptr := (*reflect.StringHeader) (unsafe.Pointer(a))
bptr := (*reflect.StringHeader) (unsafe.Pointer(b))
fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))
}
// 运行结果
hello,world
world
a ptr: 0xd4d849
b ptr: 0xd4d84f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
0xd4d849 - 0xd4d84f = 0x000006
显然,也没有分配新的数组并拷贝数据,而是将原字符数组的指针的偏移赋给了b的StringHeader的Data
4、string重新赋值
如果对一个已经赋值的字符串重新赋值,也不会修改原内存空间,而是申请了新的内存空间,对其赋值,并指向新的内存空间。如下图:
在这里插入图片描述
也可以使用代码来证实一下:
package main
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
a := "hello,world"
aptr := (*reflect.StringHeader) (unsafe.Pointer(a))
fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("a len", aptr.Len)
a = "hello,golang"
newAPtr := (*reflect.StringHeader) (unsafe.Pointer(a))
fmt.Println("b ptr:", unsafe.Pointer(newAPtr.Data))
fmt.Println("b len:", newAPtr.Len)
}
// 运行结果
a ptr: 0x3ed7f4
a len 11
b ptr: 0x3edb2c
b len: 12
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
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
文章知识点与官方知识档案匹配
Go技能树九阴真经字符串
2043 人正在系统学习中
点击阅读全文
打开CSDN APP,看更多技术内容
Golang底层原理剖析之string类型与字符编码_cheems~的博客_g...
string类型 string结构 go语言中默认使用的是UTF-8编码 string由两部分组成,一部分是指向字符串起始地址的指针,另一部分是字节个数len注意不是字符个数,是字节个数!这个数据类型占用16B空间,指向字符串起始地址的指针和存在字节个数的整...
继续访问
...底层系列二(基础)_GoGo在努力的博客_golang string底层
1、 string的定义 Golang中的string的定义在reflect包下的value.go中,定义如下: StringHeader 是字符串的运行时表示,其中包含了两个字段,分别是指向数据数组的指针和数组的长度。 // StringHeader is the runtime representation of a...
继续访问
最新发布 Golang: []string 和 ...string
… 参数语法形成了可变参数的参数。它将接受零个或多个string参数,并将它们作为切片引用
继续访问
常用的Golang字符串(string)操作
文章目录Golang中常用的字符串操作一、标准库相关的Package二、常用字符串操作判断是否为空字符串 正文 Golang中常用的字符串操作 一、标准库相关的Package 二、常用字符串操作 判断是否为空字符串 思路:直接判断是否等于""空字符串,由于golang中字符串不能为nil,且为值类型,所以直接与空字符串比较即可 举例: str := "" if str == ""{...
继续访问
golang中的string_xiaodongdonga的博客_golang ...string
golang中的string 在golang中,string其实是个结构体,如图 ,在这个结构体中有两个值,一个是指向字符数组的指针str,另一个是这个字符串的长度len。 另外在golang中用的是UFT8边长编码,里面字母是用一个字节,西方的文字使用两个字节,...
继续访问
Golang中对字符串string的相关操作_Codex_97的博客_go 字符...
golang中拥有string的内置类型,可以使用与普通slice类型相似的性质。 1.简介 strings包提供了很多操作字符串的简单函数,通常一般的字符串操作都可以在这个包中找到。 strconv 包提供了基本数据类型和字符串之间的转换。在Go 中,没有隐式...
继续访问
go-string-set:一种在GoLang中创建字符串集的方法
概述 通过字符串设置方法。 用法 go get github.com/wojnosystems/go-string-set package main import ( "github.com/wojnosystems/go-string-set/string_set" "strings" ) func main () { myPeople := string_set . New () myPeople . Add ( "Bob" ) myPeople . Add ( "Jane" ) myPeople . Add ( "Gary" ) myPeople . Add ( "Bob" ) if myPeople . Exists ( "Bob" ) { // Bob exists in myPeople, so this code block execute
Golang:strings包和字符串操作
strings包 string类型值是不可变的,如果想要获得一个不一样的字符串,就只能基于原字符串进行剪裁,拼接等操作,然后将得到的新字符串存放到一块联系内存中。 string值包含了指向底层字节数组头部的指针值,以及该字节数组的长度。在string值上做切片,就相当于在其底层字节数组做切片。 而字符串拼接时(使用+),会把所有被拼接的字符串依次拷贝到一个崭新且足够大的连续内存空间中,并把持有新...
继续访问
golang中的strings.SplitN_盼盼编程的博客_strings.splitn
golang中的字符串操作strings.SplitN package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "hello world hello world" //str := "wo" //以str为分隔符,将s切分成多个子串,结果中**不包含*...
继续访问
Golang_String常用操作_itzhuzhu.的博客_golang strings
func main() { var x string = "ITzhuzhu" var y string = "itzhuzhu" fmt.Println(strings.EqualFold(x, y)) //true fmt.Println(x == y) //false } 1 2 3 4 5 6 返回子串在字符串第一次出现的索引,如果没有则...
继续访问
Golang类型的String()方法
作用 用于定制fmt.Println(x)、fmt.Printf("%v", x)、fmt.Print(x)时输出的内容。 示例 package main import "fmt" type Couple struct { Husband string Wife string } func (self Couple) String() string { return "(husband:" + self.Husband + ", wife:" + self.Wife +
继续访问
golang的string
golang中的string是不可变的字节序列,零值是空字符串,默认是UTF-8编码。 golang中使用字符串最需要注意的是,golang中的字符串是字节序列,string == []byte,由于一个字符占用的字节数不确定,所以无法通过下标[i]的方式稳定地获取对应位置的字符。 也就意味着字符串的第i个字节,不一定就是第i个字符,原因请参考 unicode与UTF-8 文字符号在golang中被称为rune,发音为/ru:n/,意思是符号。由于utf-8最多使用4个字节来编码,所以rune类型是int3
继续访问
golang中的strings.Trim_盼盼编程的博客_strings.trim
golang中的字符串操作strings.Trim package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "Hello world hello world" str := "world" //var s = []string{"11","22","33"} //删除s首尾...
继续访问
Golang 字符串
Go语言的代码是由Unicode字符组成的,它们都必须由Unicode编码规范中的UTF-8编码格式进行编码并存储,Unicode编码规范中的编码格式定义的是字符与字节序列之间的转换方式。其中的UTF-8是一种可变宽的编码方案,它会用一个或多个字节的二进制数来表示某个字符,最多使用四个字节。Go语言中的一个string类型值会由若干个Unicode字符组成,每个Unicode字符都可以由一个rune类型的值来承载。stringforrange。...
继续访问
golang字符串[]string(slice)去重
1、现实代码 // []string 去重 func RemoveDuplicate(list []string) []string { // 这个排序很关键 sort.Strings(list) i := 0 var newlist = []string{""} for j := 0; j len(list); j++ { if strings.Compare(newlist[i], list[j]) == -1 { newlist = append(newlist, lis
继续访问
深入理解golang string
golang string string的定义 // string is the set of all strings of 8-bit bytes, conventionally but not // necessarily representing UTF-8-encoded text. A string may be empty, but // not nil. Values of string type are immutable. type string string string里存储的是字符
继续访问
golang中string包
对于基本类型来说,字符串所需要执行的操作会比较复杂,所以一般语言都会额外封装一些方法用于处理字符串,go语言标准库中也存在这样一个名为strings的库 包含判断,判断一个字符中是否有相应的某个子字符串是经常遇到的一种字符串操作,再go语言中可以使用strings包中的两个方法判断 ...
继续访问
golang中的strings.TrimLeft
golang中的字符串操作strings.TrimLeft package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "Hello world hello world" str := "Hello" //var s = []string{"11","22","33"} //删除s头部连续的包含在str中的字符串 .
继续访问
golang入门time与string转换, time加减时间, 两个时间差
package mainimport ( "fmt" "time")var timeLayoutStr = "2006-01-02 15:04:05" //go中的时间格式化必须是这个时间//var timeLayoutStr = 2006/01/02 03:04:05 //合法, 格式可以改变//var timeLayoutStr = 2019/01/02 15:04:05 /...
继续访问
Golang——string
1.string结构体底层 由两部分组成:指向底层[ ]byte数组的指针;长度(类似切片结构体) 2.相同的string常量不会重复存储 //由s1、s2的指针指向一块相同的只读内存,这段内存以utf-8编码存放hello数组 s1 := "hello" s2 := "hello" 3.string常量会在编译期分配到只读段,对应数据地址不可写入,故string不支持修改。 要修改必须转[]byte,string和[]byte转换,会将这段只读内存的数据复制到堆/栈上。 //wrong s := "he
继续访问
热门推荐 golang -----------字符串(rune,string,type)
一、内存布局 字符串在Go语言内存模型中用一个2字长的数据结构表示。它包含一个指向字符串存储数据的指针和一个长度数据。因为string类型是不可变的,对于多字符串共享同一个存储数据是安全的。切分操作str[i:j]会得到一个新的2字长结构,一个可能不同的但仍指向同一个字节序列(即上文说的存储数据)的指针和长度数据。这意味着字符串切分可以在不涉及内存分配或复制操作。这使得字符串切分的效率等同于...
继续访问
Golang string 常用方法
strings.Compare(p1, p2) 判断p1是否大于p2,大于:1,小于:-1,等于:0。2.strings.LastIndex(p1,p2) p2在p1中最后一次出现的位置,未出现返回-1。1.strings.Replace(p1,p2,p3,n) 将p1中的p2替换成p3,最多替换n个。1.strings.Index(p1,p2) p2在p1中第一次出现的位置,未出现返回-1。2.strings.ReplaceAll(p1,p2,p3) 将p1中的所有p2替换成p3。
继续访问
golang中的字符串
在go中rune是一个unicode编码点。 我们都知道UTF-8将字符编码为1-4个字节,比如我们常用的汉字,UTF-8编码为3个字节。所以rune也是int32的别名。
继续访问
golang之字符串
Go语言的字符有两种类型: 一种是byte型,或者叫uint8类型,代表了ASCII码的一个字符。 一种是rune类型,或者叫int32类型,代表一个UTF-8字符,当需要处理中文、日文等unicode字符时,则需要用到rune类型。 ...
继续访问
Golang的 string 类型
一点睛 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 二 string 使用注意事项和细节 1 Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本,这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员。 2 字符串一旦赋值了,字符串就不能修改了,在 Go 中字符串是不可变的。 3 字符串的两种表示形式。 a 双引号——会识别转义字符 .
继续访问
Golang Strings 官方包常用方法,学会这些够用了
1.判断是否以某字符串打头/结尾 2.字符串分割 3.返回子串索引 4.字符串连接 5.字符串转化为大小写 6.统计某个字符在字符串出现的次数 7.判断字符串的包含关系 8.字符串替换
前言
最近工作中遇到的一个场景,php项目中需要使用一个第三方的功能,而恰好有一个用Golang写好的类库。那么问题就来了,要如何实现不同语言之间的通信呢?下面就来一起看看吧。
常规的方案
1、 用Golang写一个http/TCP服务,php通过http/TCP与Golang通信
2、将Golang经过较多封装,做为php扩展。
3、PHP通过系统命令,调取Golang的可执行文件
存在的问题
1、http请求,网络I/O将会消耗大量时间
2、需要封装大量代码
3、PHP每调取一次Golang程序,就需要一次初始化,时间消耗很多
优化目标
1、Golang程序只初始化一次(因为初始化很耗时)
2、所有请求不需要走网络
3、尽量不大量修改代码
解决方案
1、简单的Golang封装,将第三方类库编译生成为一个可执行文件
2、PHP与Golang通过双向管道通信
使用双向管道通信优势
1:只需要对原有Golang类库进行很少的封装
2:性能最佳 (IPC通信是进程间通信的最佳途径)
3:不需要走网络请求,节约大量时间
4:程序只需初始化一次,并一直保持在内存中
具体实现步骤
1:类库中的原始调取demo
package main
import (
"fmt"
"github.com/yanyiwu/gojieba"
"strings"
)
func main() {
x := gojieba.NewJieba()
defer x.Free()
s := "小明硕士毕业于中国科学院计算所,后在日本京都大学深造"
words := x.CutForSearch(s, true)
fmt.Println(strings.Join(words, "/"))
}
保存文件为main.go,就可以运行
2:调整后代码为:
package main
import (
"bufio"
"fmt"
"github.com/yanyiwu/gojieba"
"io"
"os"
"strings"
)
func main() {
x := gojieba.NewJieba(
"/data/tmp/jiebaDict/jieba.dict.utf8",
"/data/tmp/jiebaDict/hmm_model.utf8",
"/data/tmp/jiebaDict/user.dict.utf8"
)
defer x.Free()
inputReader := bufio.NewReader(os.Stdin)
for {
s, err := inputReader.ReadString('\n')
if err != nil err == io.EOF {
break
}
s = strings.TrimSpace(s)
if s != "" {
words := x.CutForSearch(s, true)
fmt.Println(strings.Join(words, " "))
} else {
fmt.Println("get empty \n")
}
}
}
只需要简单的几行调整,即可实现:从标准输入接收字符串,经过分词再输出
测试:
# go build test
# ./test
# //等待用户输入,输入”这是一个测试“
# 这是 一个 测试 //程序
3:使用cat与Golang通信做简单测试
//准备一个title.txt,每行是一句文本
# cat title.txt | ./test
正常输出,表示cat已经可以和Golang正常交互了
4:PHP与Golang通信
以上所示的cat与Golang通信,使用的是单向管道。即:只能从cat向Golang传入数据,Golang输出的数据并没有传回给cat,而是直接输出到屏幕。但文中的需求是:php与Golang通信。即php要传数据给Golang,同时Golang也必须把执行结果返回给php。因此,需要引入双向管道。
在PHP中管道的使用:popen("/path/test") ,具体就不展开说了,因为此方法解决不了文中的问题。
双向管道:
$descriptorspec = array(
0 = array("pipe", "r"),
1 = array("pipe", "w")
);
$handle = proc_open(
'/webroot/go/src/test/test',
$descriptorspec,
$pipes
);
fwrite($pipes['0'], "这是一个测试文本\n");
echo fgets($pipes[1]);
解释:使用proc_open打开一个进程,调用Golang程序。同时返回一个双向管道pipes数组,php向$pipe['0']中写数据,从$pipe['1']中读数据。
好吧,也许你已经发现,我是标题档,这里重点要讲的并不只是PHP与Golang如何通信。而是在介绍一种方法: 通过双向管道让任意语言通信。(所有语言都会实现管道相关内容)
测试:
通过对比测试,计算出各个流程占用的时间。下面提到的title.txt文件,包含100万行文本,每行文本是从b2b平台取的商品标题
1: 整体流程耗时
time cat title.txt | ./test /dev/null
耗时:14.819秒,消耗时间包含:
进程cat读出文本
通过管道将数据传入Golang
Golang处理数据,将结果返回到屏幕
2:计算分词函数耗时。方案:去除分词函数的调取,即:注释掉Golang源代码中的调取分词那行的代码
time cat title.txt | ./test /dev/null
耗时:1.817秒时间,消耗时间包含:
进程cat读出文本
通过管道将数据传入Golang
Golang处理数据,将结果返回到屏幕
分词耗时 = (第一步耗时) - (以上命令所耗时)
分词耗时 : 14.819 - 1.817 = 13.002秒
3:测试cat进程与Golang进程之间通信所占时间
time cat title.txt /dev/null
耗时:0.015秒,消耗时间包含:
进程cat读出文本
通过管道将数据传入Golang
go处理数据,将结果返回到屏幕
管道通信耗时:(第二步耗时) - (第三步耗时)
管道通信耗时: 1.817 - 0.015 = 1.802秒
4:PHP与Golang通信的时间消耗
编写简单的php文件:
?php
$descriptorspec = array(
0 = array("pipe", "r"),
1 = array("pipe", "w")
);
$handle = proc_open(
'/webroot/go/src/test/test',
$descriptorspec,
$pipes
);
$fp = fopen("title.txt", "rb");
while (!feof($fp)) {
fwrite($pipes['0'], trim(fgets($fp))."\n");
echo fgets($pipes[1]);
}
fclose($pipes['0']);
fclose($pipes['1']);
proc_close($handle);
流程与上面基本一致,读出title.txt内容,通过双向管道传入Golang进程分词后,再返回给php (比上面的测试多一步:数据再通过管道返回)
time php popen.php /dev/null
耗时:24.037秒,消耗时间包含:
进程PHP读出文本
通过管道将数据传入Golang
Golang处理数据
Golang将返回结果再写入管道,PHP通过管道接收数据
将结果返回到屏幕
结论:
1 :整个分词过程中的耗时分布
使用cat控制逻辑耗时: 14.819 秒
使用PHP控制逻辑耗时: 24.037 秒(比cat多一次管道通信)
单向管道通信耗时: 1.8 秒
Golang中的分词函数耗时: 13.002 秒
2:分词函数的性能: 单进程,100万商品标题分词,耗时13秒
以上时间只包括分词时间,不包括词典载入时间。但在本方案中,词典只载入一次,所以载入词典时间可以忽略(1秒左右)
3:PHP比cat慢 (这结论有点多余了,呵呵)
语言层面慢: (24.037 - 1.8 - 14.819) / 14.819 = 50%
单进程对比测试的话,应该不会有哪个语言比cat更快。
相关问题:
1:以上Golang源码中写的是一个循环,也就是会一直从管道中读数据。那么存在一个问题:是不是php进程结束后,Golang的进程还会一直存在?
管道机制自身可解决此问题。管道提供两个接口:读、写。当写进程结束或者意外挂掉时,读进程也会报错,以上Golang源代码中的err逻辑就会执行,Golang进程结束。
但如果PHP进程没有结束,只是暂时没有数据传入,此时Golang进程会一直等待。直到php结束后,Golang进程才会自动结束。
2:能否多个php进程并行读写同一个管道,Golang进程同时为其服务?
不可以。管道是单向的,如果多个进程同时向管道中写,那Golang的返回值就会错乱。
可以多开几个Golang进程实现,每个php进程对应一个Golang进程。
最后,上面都是瞎扯的。如果你了解管道、双向管道,上面的解释对你基本没啥用。但如果你不了解管道,调试上面的代码没问题,但稍有修改就有可能掉坑里。
GO中的defer会在当前函数返回前执行传入的函数,常用于关闭文件描述符,关闭链接及解锁等操作。
Go语言中使用defer时会遇到两个常见问题:
接下来我们来详细处理这两个问题。
官方有段对defer的解释:
这里我们先来一道经典的面试题
你觉得这个会打印什么?
输出结果:
这里是遵循先入后出的原则,同时保留当前变量的值。
把这道题简化一下:
输出结果
上述代码输出似乎不符合预期,这个现象出现的原因是什么呢?经过分析,我们发现调用defer关键字会立即拷贝函数中引用的外部参数,所以fmt.Println(i)的这个i是在调用defer的时候就已经赋值了,所以会直接打印1。
想要解决这个问题也很简单,只需要向defer关键字传入匿名函数
这里把一些垃圾回收使用的字段忽略了。
中间代码生成阶段cmd/compile/internal/gc/ssa.go会处理程序中的defer,该函数会根据条件不同,使用三种机制来处理该关键字
开放编码、堆分配和栈分配是defer关键字的三种方法,而Go1.14加入的开放编码,使得关键字开销可以忽略不计。
call方法会为所有函数和方法调用生成中间代码,工作内容:
defer关键字在运行时会调用deferproc,这个函数实现在src/runtime/panic.go里,接受两个参数:参数的大小和闭包所在的地址。
编译器不仅将defer关键字转成deferproc函数,还会通过以下三种方式为所有调用defer的函数末尾插入deferreturn的函数调用
1、在cmd/compile/internal/gc/walk.go的walkstmt函数中,在遇到ODEFFER节点时会执行Curfn.Func.SetHasDefer(true),设置当前函数的hasdefer属性
2、在ssa.go的buildssa会执行s.hasdefer = fn.Func.HasDefer()更新hasdefer
3、在exit中会根据hasdefer在函数返回前插入deferreturn的函数调用
runtime.deferproc为defer创建了一个runtime._defer结构体、设置它的函数指针fn、程序计数器pc和栈指针sp并将相关参数拷贝到相邻的内存空间中
最后调用的return0是唯一一个不会触发延迟调用的函数,可以避免deferreturn的递归调用。
newdefer的分配方式是从pool缓存池中获取:
这三种方式取到的结构体_defer,都会被添加到链表的队头,这也是为什么defer按照后进先出的顺序执行。
deferreturn就是从链表的队头取出并调用jmpdefer传入需要执行的函数和参数。
该函数只有在所有延迟函数都执行后才会返回。
如果我们能够将部分结构体分配到栈上就可以节约内存分配带来的额外开销。
在call函数中有在栈上分配
在运行期间deferprocStack只需要设置一些未在编译期间初始化的字段,就可以将栈上的_defer追加到函数的链表上。
除了分配的位置和堆的不同,其他的大致相同。
Go语言在1.14中通过开放编码实现defer关键字,使用代码内联优化defer关键的额外开销并引入函数数据funcdata管理panic的调用,该优化可以将 defer 的调用开销从 1.13 版本的 ~35ns 降低至 ~6ns 左右。
然而开放编码作为一种优化 defer 关键字的方法,它不是在所有的场景下都会开启的,开放编码只会在满足以下的条件时启用:
如果函数中defer关键字的数量多于8个或者defer处于循环中,那么就会禁用开放编码优化。
可以看到这里,判断编译参数不用-N,返回语句的数量和defer数量的乘积小于15,会启用开放编码优化。
延迟比特deferBitsTemp和延迟记录是使用开放编码实现defer的两个最重要的结构,一旦使用开放编码,buildssa会在栈上初始化大小为8个比特的deferBits
延迟比特中的每一个比特位都表示该位对应的defer关键字是否需要被执行。延迟比特的作用就是标记哪些defer关键字在函数中被执行,这样就能在函数返回时根据对应的deferBits确定要执行的函数。
而deferBits的大小为8比特,所以该优化的条件就是defer的数量小于8.
而执行延迟调用的时候仍在deferreturn
这里做了特殊的优化,在runOpenDeferFrame执行开放编码延迟函数
1、从结构体_defer读取deferBits,执行函数等信息
2、在循环中依次读取执行函数的地址和参数信息,并通过deferBits判断是否要执行
3、调用reflectcallSave执行函数
1、新加入的defer放入队头,执行defer时是从队头取函数调用,所以是后进先出
2、通过判断defer关键字、return数量来判断是否开启开放编码优化
3、调用deferproc函数创建新的延迟调用函数时,会立即拷贝函数的参数,函数的参数不会等到真正执行时计算
参考:
Goroutine并发调度模型深度解析手撸一个协程池
Golang 的 goroutine 是如何实现的?
Golang - 调度剖析【第二部分】
OS线程初始栈为2MB。Go语言中,每个goroutine采用动态扩容方式,初始2KB,按需增长,最大1G。此外GC会收缩栈空间。
BTW,增长扩容都是有代价的,需要copy数据到新的stack,所以初始2KB可能有些性能问题。
更多关于stack的内容,可以参见大佬的文章。 聊一聊goroutine stack
用户线程的调度以及生命周期管理都是用户层面,Go语言自己实现的,不借助OS系统调用,减少系统资源消耗。
Go语言采用两级线程模型,即用户线程与内核线程KSE(kernel scheduling entity)是M:N的。最终goroutine还是会交给OS线程执行,但是需要一个中介,提供上下文。这就是G-M-P模型
Go调度器有两个不同的运行队列:
go1.10\src\runtime\runtime2.go
Go调度器根据事件进行上下文切换。
调度的目的就是防止M堵塞,空闲,系统进程切换。
详见 Golang - 调度剖析【第二部分】
Linux可以通过epoll实现网络调用,统称网络轮询器N(Net Poller)。
文件IO操作
上面都是防止M堵塞,任务窃取是防止M空闲
每个M都有一个特殊的G,g0。用于执行调度,gc,栈管理等任务,所以g0的栈称为调度栈。g0的栈不会自动增长,不会被gc,来自os线程的栈。
go1.10\src\runtime\proc.go
G没办法自己运行,必须通过M运行
M通过通过调度,执行G
从M挂载P的runq中找到G,执行G
Go有四大核心模块,基本全部体现在runtime,有调度系统、GC、goroutine、channel,那么深入理解其中的精髓可以帮助我们理解Go这一门语言!
参考: 调度系统设计精要
下面是我用Go语言简单写的一个调度器,大家可以看看设计思路,以及存在的问题!
1、测试条件,调度器只启动两个线程,然后一个线程主要是负责循环的添加任务,一个线程循环的去执行任务
2、测试条件,调度器启动三个线程,然后两个线程去执行任务,一个添加任务
3、继续测试,启动十个线程,一个添加任务,九个执行任务
4、我们添加一些阻塞的任务
执行可以看到完全不可用
1、 可以看到随着M的不断的增加,可以发现执行任务的数量也不断的减少,原因是什么呢?有兴趣的同学可以加一个pprof可以看看,其实大量的在等待锁的过程!
2、如果我的M运行了类似于Sleep操作的方法如何解决了,我的调度器还能支撑这个量级的调度吗?
关于pprof如何使用:在代码头部加一个这个代码:
我们查看一下 go tool pprof main/prof.pporf
可以看到真正执行代码的时间只有 0.17s + 0.02s 其他时间都被阻塞掉了!
1、GM模型中的所有G都是放入到一个queue,那么导致所有的M取执行任务时都会去竞争锁,我们插入G也会去竞争锁,所以解决这种问题一般就是减少对单一资源的竞争,那就是桶化,其实就是每个线程都分配一个队列
2、GM模型中没有任务状态,只有runnable,假如任务遇到阻塞,完全可以把任务挂起再唤醒
这里其实会遇到一个问题,假如要分配很多个线程,那么此时随着线程的增加,也会造成队列的增加,其实也会造成调度器的压力,因为它需要遍历全部线程的队列去分配任务以及后续会讲到的窃取任务!
因为我们知道CPU的最大并行度其实取决于CPU的核数,也就是我们没必要为每个线程都去分配一个队列,因为就算是给他们分配了,他们自己去那执行调度,其实也会出现大量阻塞,原因就是CPU调度不过来这些线程!
Go里面是只分配了CPU个数的队列,这里就是P这个概念,你可以理解为P其实是真正的资源分配器,M很轻只是执行程序,所有的资源内存都维护在P上!M只有绑定P才能执行任务(强制的)!
这样做的好处:
1、首先调度程序其实就是调度不同状态的任务,go里面为Go标记了不同的状态,其实大概就是分为:runnable,running,block等,所以如何充分调度不同状态的G成了问题,那么关于阻塞的G如何解决,其实可以很好的解决G调度的问题!
上面这些情况其实就分为:
2、用户态阻塞,一般Go里面依靠 gopark 函数去实现,大体的代码逻辑基本上和go的调度绑定死了
源码在:
3、其实对于netpool 这种nio模型,其实内核调用是非阻塞的,所以go开辟了一个网络轮训器队列,来存放这些被阻塞的g,等待内核被唤醒!那么什么时候会被唤醒了,其实就是需要等待调度器去调度了!
4、如果是内核态阻塞了(内核态阻塞一般都会将线程挂起,线程需要等待被唤醒),我们此时P只能放弃此线程的权利,然后再找一个新的线程去运行P!
关于着新线程:找有没有idle的线程,没有就会创建一个新的线程!
关于当内核被唤醒后的操作:因为GPM模型所以需要找到个P绑定,所以G会去尝试找一个可用的P,如果没有可用的P,G会标记为runnable放到全局队列中!
5、其实了解上面大致其实就了解了Go的基本调度模型
答案文章里慢慢品味!
如果某个 G 执行时间过长,其他的 G 如何才能被正常的调度? 这便涉及到有关调度的两个理念:协作式调度与抢占式调度。协作式和抢占式这两个理念解释起来很简单: 协作式调度依靠被调度方主动弃权;抢占式调度则依靠调度器强制将被调度方被动中断。
例如下面的代码,我本地的版本是 go1.13.5
执行: GOMAXPROCS=1 配置全局只能有一个P
可以看到main函数无法执行!也就是那个go 空转抢占了整个程序
备注:
但是假如我换为用 1.14+版本执行,有兴趣的话可以使用我的docker镜像,直接可以拉取: fanhaodong/golang:1.15.11 和 fanhaodong/golang:1.13.5
首先我们知道G/M/P,G可能和M也可能和P解除绑定,那么关于数据变量放在哪哇!其实这个就是逃逸分析!
输出可以看到其实没有发生逃逸,那是因为 demo被拷贝它自己的栈空间内
备注:
-gcflags"-N -l -m" 其中 -N禁用优化-l禁止内联优化,-m打印逃逸信息
那么继续改成这个
可以看到发现 demo对象其实被逃逸到了堆上!这就是不会出现类似于G如果被别的M执行,其实不会出现内存分配位置的问题!
所以可以看到demo其实是copy到了堆上!这就是g逃逸的问题,和for循环一样的
执行可以发现,其实x已经逃逸到了堆上,所以你所有的g都引用的一个对象,如何解决了
如何解决了,其实很简单
也谈goroutine调度器
图解Go运行时调度器
Go语言回顾:从Go 1.0到Go 1.13
Go语言原本
调度系统设计精要
Scalable Go Scheduler Design Doc
在Go语言中有一些调试技巧能帮助我们快速找到问题,有时候你想尽可能多的记录异常但仍觉得不够,搞清楚堆栈的意义有助于定位Bug或者记录更完整的信息。
本文将讨论堆栈跟踪信息以及如何在堆栈中识别函数所传递的参数。
Functions
先从这段代码开始:
Listing 1
01 package main
02
03 func main() {
04 slice := make([]string, 2, 4)
05 Example(slice, "hello", 10)
06 }
07
08 func Example(slice []string, str string, i int) {
09 panic("Want stack trace")
10 }
Example函数定义了3个参数,1个string类型的slice, 1个string和1个integer, 并且抛出了panic,运行这段代码可以看到这样的结果:
Listing 2
Panic: Want stack trace
goroutine 1 [running]:
main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:9 +0x64
main.main()
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:5 +0x85
goroutine 2 [runnable]:
runtime.forcegchelper()
/Users/bill/go/src/runtime/proc.go:90
runtime.goexit()
/Users/bill/go/src/runtime/asm_amd64.s:2232 +0x1
goroutine 3 [runnable]:
runtime.bgsweep()
/Users/bill/go/src/runtime/mgc0.go:82
runtime.goexit()
/Users/bill/go/src/runtime/asm_amd64.s:2232 +0x1
堆栈信息中显示了在panic抛出这个时间所有的goroutines状态,发生的panic的goroutine会显示在最上面。
Listing 3
01 goroutine 1 [running]:
02 main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:9 +0x64
03 main.main()
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:5 +0x85
第1行显示最先发出panic的是goroutine 1, 第二行显示panic位于main.Example中, 并能定位到该行代码,在本例中第9行引发了panic。
下面我们关注参数是如何传递的:
Listing 4
// Declaration
main.Example(slice []string, str string, i int)
// Call to Example by main.
slice := make([]string, 2, 4)
Example(slice, "hello", 10)
// Stack trace
main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)
这里展示了在main中带参数调用Example函数时的堆栈信息,比较就能发现两者的参数数量并不相同,Example定义了3个参数,堆栈中显示了6个参数。现在的关键问题是我们要弄清楚它们是如何匹配的。
第1个参数是string类型的slice,我们知道在Go语言中slice是引用类型,即slice变量结构会包含三个部分:指针、长度(Lengthe)、容量(Capacity)
Listing 5
// Slice parameter value
slice := make([]string, 2, 4)
// Slice header values
Pointer: 0x2080c3f50
Length: 0x2
Capacity: 0x4
// Declaration
main.Example(slice []string, str string, i int)
// Stack trace
main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)
因此,前面3个参数会匹配slice, 如下图所示:
Figure 1
figure provided by Georgi Knox
我们现在来看第二个参数,它是string类型,string类型也是引用类型,它包括两部分:指针、长度。
Listing 6
// String parameter value
"hello"
// String header values
Pointer: 0x425c0
Length: 0x5
// Declaration
main.Example(slice []string, str string, i int)
// Stack trace
main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)
可以确定,堆栈信息中第4、5两个参数对应代码中的string参数,如下图所示:
Figure 2
figure provided by Georgi Knox
最后一个参数integer是single word值。
Listing 7
// Integer parameter value
10
// Integer value
Base 16: 0xa
// Declaration
main.Example(slice []string, str string, i int)
// Stack trace
main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)
现在我们可以匹配代码中的参数到堆栈信息了。
Figure 3
figure provided by Georgi Knox
Methods
如果我们将Example作为结构体的方法会怎么样呢?
Listing 8
01 package main
02
03 import "fmt"
04
05 type trace struct{}
06
07 func main() {
08 slice := make([]string, 2, 4)
09
10 var t trace
11 t.Example(slice, "hello", 10)
12 }
13
14 func (t *trace) Example(slice []string, str string, i int) {
15 fmt.Printf("Receiver Address: %p\n", t)
16 panic("Want stack trace")
17 }
如上所示修改代码,将Example定义为trace的方法,并通过trace的实例t来调用Example。
再次运行程序,会发现堆栈信息有一点不同:
Listing 9
Receiver Address: 0x1553a8
panic: Want stack trace
01 goroutine 1 [running]:
02 main.(*trace).Example(0x1553a8, 0x2081b7f50, 0x2, 0x4, 0xdc1d0, 0x5, 0xa)
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:16 +0x116
03 main.main()
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:11 +0xae
首先注意第2行的方法调用使用了pointer receiver,在package名字和方法名之间多出了"*trace"字样。另外,参数列表的第1个参数标明了结构体(t)地址。我们从堆栈信息中看到了内部实现细节。
Packing
如果有多个参数可以填充到一个single word, 则这些参数值会合并打包:
Listing 10
01 package main
02
03 func main() {
04 Example(true, false, true, 25)
05 }
06
07 func Example(b1, b2, b3 bool, i uint8) {
08 panic("Want stack trace")
09 }
这个例子修改Example函数为4个参数:3个bool型和1个八位无符号整型。bool值也是用8个bit表示,所以在32位和64位架构下,4个参数可以合并为一个single word。
Listing 11
01 goroutine 1 [running]:
02 main.Example(0x19010001)
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:8 +0x64
03 main.main()
/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/
temp/main.go:4 +0x32
这是本例的堆栈信息,看下图的具体分析:
Listing 12
// Parameter values
true, false, true, 25
// Word value
Bits Binary Hex Value
00-07 0000 0001 01 true
08-15 0000 0000 00 false
16-23 0000 0001 01 true
24-31 0001 1001 19 25
// Declaration
main.Example(b1, b2, b3 bool, i uint8)
// Stack trace
main.Example(0x19010001)
以上展示了参数值是如何匹配到4个参数的。当我们看到堆栈信息中包括十六进制值,需要知道这些值是如何传递的。