Go官方工具链 为了从任意目录运行Go官方工具链中工具命令（通过go命令）， Go官方工具链安装目录下的bin子目录路径必须配置在PATH环境变量中。 当使用安装程序安装Go官方工具链时，安装程序很可能已经自动地将此配置好了。windows环境中需要在把安装目录下bin子目录添加到高级系统环境变量中保存生效。 Go官方工具链近来的版本都支持一个称为Go模块（Go modules）的特性， 用来管理项目依赖。此特性在版本1.11中被试验性引入， 在版本1.16中被默认支持。 第一个环境变量 我们应该了解一个环境变量：GOPATH。 此环境变量的默认值为当前用户的HOME目录下的名为go文件夹对应的目录路径。 GOPATH环境变量可以被手动地配置多个路径。 以后，当GOPATH文件夹被提及的时候，它表示GOPATH环境变量中的第一个路径对应的文件夹。 GOPATH文件夹中的pkg子文件夹用来缓存被本地项目所依赖的Go模块（一个Go模块为若干Go库包的集合）的版本。 GOBIN环境变量用来指定go install子命令产生的Go应用程序二进制可执行文件应该存储在何处。 它的默认值为GOPATH文件夹中的bin子目录所对应的目录路径。 GOBIN路径需配置在PATH环境变量中，以便从任意目录运行这些Go应用程序。 运行一个程序 Go官方工具链工具要求所有的Go源代码文件必须以.go后缀结尾。这里，我们假设一个最简单的Go程序放在hello.go的文件中。下面是最简单的Go程序。 package main import "fmt" func main() { fmt.Println("hello") } 打开一个终端（控制台）并进入上述源文件所在的目录，然后运行 $ go run hello.go 如果代码中有语法错误，这些错误将输出在终端中。 如果一个程序的main包中有若干Go源代码文件，我们可以使用下面的命令运行此程序。 $ go run . 注意： go run子命令并不推荐在正式的大项目中使用。go run子命令只是一种方便的方式来运行简单的Go程序。 对于正式的项目，最好使用go build或者go install子命令构建可执行程序文件来运行Go程序。 支持Go模块特性的Go项目的根目录下需要一个go.mod文件。此文件可以使用go mod init子命令来生成（见下）。 更多go子命令 上面提到的三个go子命令（go run、go build和go install） 将只会输出代码语法错误。它们不会输出可能的代码逻辑错误（即警告）。 go vet子命令可以用来检查可能的代码逻辑错误（即警告）。 我们可以使用go fmt子命令来用同一种代码风格格式化Go代码。 我们可以使用go test子命令来运行单元和基准测试用例。 我们可以使用go doc子命令在终端中查看Go代码库包的文档。 强烈推荐让你的Go项目支持Go模块特性来简化依赖管理。对一个支持Go模块特性的项目： go mod init example.com/myproject命令可以用来在当前目录中生成一个go.mod文件。 当前目录将被视为一个名为example.com/myproject的模块（即当前项目）的根目录。 此go.mod文件将被用来记录当前项目需要的依赖模块和版本信息。 我们可以手动编辑或者使用go子命令来修改此文件。 go mod tidy命令用来通过扫描当前项目中的所有代码来添加未被记录的依赖至go.mod文件或从go.mod文件中删除不再被使用的依赖。 go get命令用拉添加、升级、降级或者删除单个依赖。此命令不如go mod tidy命令常用。 从Go官方工具链1.16版本开始，我们可以运行go install example.com/program@latest来安装一个第三方Go程序的最新版本（至GOBIIN目录）。 在Go官方工具链1.16版本之前，对应的命令是go get -u example.com/program（现在已经被废弃而不再推荐被使用了）。 我们可以运行go help aSubCommand来查看一个子命令aSubCommand的帮助信息。 运行不带参数的go命令将会列出所有支持的go子命令。 到此这篇关于Go官方工具链用法简介的文章就介绍到这了,更多相关Go工具链内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

说明： Go 语言切片是对数组的抽象。 Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。 一、定义切片 注意：切片不需要说明长度 1、声明一个未指定大小的数组来定义切片 var identifier []type //例如 var slice []int 2、使用make()函数来创建切片 var slice1 []type = make([]type, len) //也可以简写为 slice1 := make([]type, len) //例如 slice := make([]type, len) 二、切片是可索引的 1、len() 和 cap() 函数 可以由 len() 方法获取长度。 切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少 package main import "fmt" func main(){ var number = make([]int,3,5) fmt.Printf("len=%d cap=%d slice=%v\n",len(number),cap(number),number) } //len=3 cap=5 slice=[0 0 0] 2、空(nil)切片 一个切片在未初始化之前默认为 nil，长度为 0 package main import "fmt" func main(){ var number []int fmt.Printf("len=%d cap=%d slice=%v\n",len(number),cap(number),number) } //len=0 cap=0 slice=[] 三、切片截取 可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound] package main import "fmt" func main() { //创建切片 number := []int{0, 1, 2, 3, 4, 5, 6, 7, 8} printSlice(number) //打印原始切片 fmt.Println("number == ", number) //打印子切片从索引1到索引4 fmt.Println("number == ", number[1:4]) //打印子切片默认下限 fmt.Println("number == ", number[:3]) //打印子切片默认上限 fmt.Println("number == ", number[4:]) } func printSlice(x []int) { fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x) } 结果： 四、增加切片的容量 原理：创建一个新的更大的切片并把原分片的内容都拷贝过来 append() 和 copy() 函数 package main import ( "fmt" ) func main() { //创建切片 var number []int printSlice(number) //允许追加空切片 number = append(number,0) printSlice(number) //向切片添加一个元素 number = append(number,1) printSlice(number) //同时添加多个元素 number = append(number,2,3,4) printSlice(number) //创建的新的切片是之前的切片容量的两倍 number1 := make([]int,len(number),(cap(number))*2) //拷贝number的内容到number1中 copy(number1,number) printSlice(number1) } func printSlice(x []int) { fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x) } 到此这篇关于Go语言--切片(Slice)详解的文章就介绍到这了,更多相关Go语言切片(Slice)内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1、环境变量对照表 golang交叉编译环境变量对照表 GOOS | GOARCH | OS VERSION ---|---|--- linux | 386 / amd64 / arm | >= Linux 2.6 darwin | 386 / amd64 | OX X (Snow Leopard + Lion) freebsd | 386 / amd64 | >= FreeBSD 7 windows | 386 / amd64 | >= Windows 2000 2、使用 2.1 Windows Windows 下编译 Mac 64位可执行程序 set CGO_ENABLED=0 set GOOS=darwin set GOARCH=amd64 go build main.go Windows 下编译 Linux 64位可执行程序 set CGO_ENABLED=0 set GOOS=linux set GOARCH=amd64 go build main.go 2.2 linux Linux 下编译 Mac 64位可执行程序 export CGO_ENABLED=0 export GOOS=darwin export GOARCH=amd64 go build main.go Linux 下编译 Windows 64位可执行程序 export CGO_ENABLED=0 export GOOS=windows export GOARCH=amd64 go build main.go 2.3 Mac OS Mac 下编译 Windows 64位可执行程序 export CGO_ENABLED=0 export GOOS=windows export GOARCH=amd64 go build main.go Mac 下编译 Linux 64位可执行程序 export CGO_ENABLED=0 export GOOS=linux export GOARCH=amd64 go build main.go 3、备注 3.1 CGO_ENABLED解释 默认情况下，Go的runtime环境变量CGO_ENABLED=1，即默认开始cgo，允许你在Go代码中调用C代码 如果标准库中是在CGO_ENABLED=1情况下编译的，那么编译出来的最终二进制文件可能是动态链接，所以建议设置 CGO_ENABLED=0以避免移植过程中出现的不必要问题。 到此这篇关于golang交叉编译详细的文章就介绍到这了,更多相关Golang交叉编译内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1. 开启泛型 在 Go1.17 版本中，可以通过: export GOFLAGS="-gcflags=-G=3" 或者在编译运行程序时加上： go run -gcflags=-G=3 main.go 2.无泛型代码和泛型代码 2.1. AddSlice 首先看现在没有泛型的代码：  package main ​ import ( "fmt" ) ​ func AddIntSlice(input []int, diff int) []int { output := make([]int, 0, len(input)) for _, item := range input { output = append(output, item+diff) } return output } ​ func AddStrSlice(input []string, diff string) []string { output := make([]string, 0, len(input)) for _, item := range input { output = append(output, item+diff) } return output } ​ func main() { intSlice := []int{1, 2, 3, 4, 5, 6} fmt.Printf("intSlice [%+v] + 2 = [%+v]\n", intSlice, AddIntSlice(intSlice, 2)) ​ strSlice := []string{"hi,", "hello,", "bye,"} fmt.Printf("strSlice [%+v] + man = [%+v]\n", strSlice, AddStrSlice(strSlice, "man")) } //output //intSlice [[1 2 3 4 5 6]] + 2 = [[3 4 5 6 7 8]] //strSlice [[hi, hello, bye,]] + man = [[hi,man hello,man bye,man]] 上面没有使用泛型的代码中，对 intSlice 和 strSlice，需要构造两个函数对它们进行处理；而如果后续还有 float64、uint32 等类型就需要更多地 Add...Slice 函数。 而如果使用泛型之后，这些 Add...Slice 函数就可以合并为一个函数了，在这个函数中，对那些可以使用 + 操作符的类型进行加操作（无论是数学的加还是字符串的连接）。 泛型代码如下： package main ​ import ( "fmt" ) ​ type PlusConstraint interface { type int, string } ​ func AddSlice[T PlusConstraint](input []T, diff T) []T { output := make([]T, 0, len(input)) for _, item := range input { output = append(output, item+diff) } return output } ​ func main() { intSlice := []int{1, 2, 3, 4, 5} fmt.Printf("intSlice [%+v] + 2 = [%v]\n", intSlice, AddSlice(intSlice, 2)) ​ strSlice := []string{"hi,", "hello,", "bye,"} fmt.Printf("strSlice [%v] + man = [%v]\n", strSlice, AddSlice(strSlice, "man")) } //output //intSlice [[1 2 3 4 5]] + 2 = [[3 4 5 6 7]] //strSlice [[hi, hello, bye,]] + man = [[hi,man hello,man bye,man]] 是不是超级简单，但是 AddSlice 函数中引入了约束的概念，即 PlusConstraint。AddSlice 的方括号中是类型参数，T 就是这个类型参数的形参，后面的 PlusConstraint 就是 T 的约束条件，意思是只有满足约束条件的 T 类型才可以在这个函数中使用。 AddSlice 后面圆括号中的参数是常规参数也称为非类型参数，它们可以不制定具体类型（int、string 等），可以使用 T 来代替。 而在 AddSlice 中，对于 T 类型的值 item，它会将 item 和 diff 进行 + 操作，可能是数学上的累加，也可能是字符串的连接。 那现在你可能要问了，T 类型就一定是支持 + 操作符的吗，有没有可能是一个 struct 呢？ 答案是：不可能。 前面说过，只有满足约束条件的 T 才可以在 AddSlice 中使用，而约束条件就是上面的 PlusConstraint。 PlusConstraint 定义的方式和接口类型的定义是一样的，只不过内部多了一行: type int, string 这句话就是说，只有 int、string 这两个类型才满足这个约束，这里涉及到类型集的概念，后续会提到。 因此，有了这个约束条件，传入到 AddSlice 的参数 input 和 diff 都是可以使用 + 操作符的。如果你的 AddSlice 函数中想传入 float46、uint64 等类型，就在 PlusConstraint 中加上这两个类型即可。 上面的代码中，只是对 int 和 string 两种基础类型进行约束。实际开发中，我们可能会定义自己的类型: type MyInt int type MyStr string 那如果在 AddSlice 中使用这两种类型可以编译通过吗？答案是可以的。在泛型草案中，这种情况是无法编译通过的，需要在约束条件中添加~int | ~string，表示底层类型是 int 或 string 的类型。而在 Go1.17 中，上面的 PlusConstraint 就包括了 int、string、以及以这两者为底层类型的类型。 package main ​ import ( "fmt" ) ​ type MyInt int type MyStr string ​ type PlusConstraint interface { type int, string } ​ func AddSlice[T PlusConstraint](input []T, diff T) []T { output := make([]T, 0, len(input)) for _, item := range input { output = append(output, item+diff) ​ } return output ​ } ​ func main() { intSlice := []MyInt{1, 2, 3, 4, 5} fmt.Printf("intSlice [%+v] + 2 = [%v]\n", intSlice, AddSlice(intSlice, 2)) ​ strSlice := []MyStr{"hi,", "hello,", "bye,"} fmt.Printf("strSlice [%v] + man = [%v]\n", strSlice, AddSlice(strSlice, "man")) ​ } //output //intSlice [[1 2 3 4 5]] + 2 = [[3 4 5 6 7]] //strSlice [[hi, hello, bye,]] + man = [[hi,man hello,man bye,man]] 2.2. 带方法的约束 StringConstraint 前面说到，约束的定义和接口很像，那如果约束中有方法呢，那不就是妥妥的接口吗？ 两者还是有区别的： 接口的成员只有方法和内嵌的接口类型 约束的成员有方法、内嵌约束类型、类型（int、string等） 看下面一个没有使用泛型的例子： package main ​ import ( "fmt" ) ​ func ConvertSliceToStrSlice(input []fmt.Stringer) []string { output := make([]string, 0, len(input)) for _, item := range input { output = append(output, item.String()) } return output } ​ type MyInt int ​ func (mi MyInt) String() string { return fmt.Sprintf("[%d]th", mi) } func ConvertIntSliceToStrSlice(input []MyInt) []string { output := make([]string, 0, len(input)) for _, item := range input { output = append(output, item.String()) } return output } ​ type MyStr string ​ func (ms MyStr) String() string { return string(ms) + "!!!" } func ConvertStrSliceToStrSlice(input []MyStr) []string { output := make([]string, 0, len(input)) for _, item := range input { output = append(output, item.String()) } return output } func main() { intSlice := []MyInt{1, 2, 3, 4} // compile error, []MyInt not match []fmt.Stringer //fmt.Printf("%v convert %v", intSlice, ConvertSliceToStrSlice(intSlice)) ​ fmt.Printf("%v convertIntToStr %v \n", intSlice, ConvertIntSliceToStrSlice(intSlice)) ​ strSlice := []MyStr{"111", "222", "333"} fmt.Printf("%v convertStrToStr %v \n", strSlice, ConvertStrSliceToStrSlice(strSlice)) // output //[[1]th [2]th [3]th [4]th] convertIntToStr [[1]th [2]th [3]th [4]th] //[111!!! 222!!! 333!!!] convertStrToStr [111!!! 222!!! 333!!!] } 上面代码中，MyInt 和 MyStr 都实现了 fmt.Stringer 接口，但是两个都无法调用 ConvertSliceToStrSlice 函数，因为它的入参是 []fmt.Stringer 类型，[]MyInt 和它不匹配，这在编译的时候就是会报错的，而如果我们想要把[]MyInt 转换为 []string，就需要定义一个入参为[]MyInt 的函数，如 ConvertIntSliceToStrSlice；对于 []MyStr，则需要另一个函数。。。那明明两者都实现了 fmt.Stringer，理论上应该都可以通过 ConvertSliceToStrSlice 啊，这也太反人类了。 哈哈，泛型实现了这个功能。   package main ​ import ( "fmt" ) ​ type StringConstraint interface { String() string } ​ func ConvertSliceToStrSlice[T StringConstraint](input []T) []string { output := make([]string, 0, len(input)) for _, item := range input { output = append(output, item.String()) } return output } ​ type MyInt int ​ func (mi MyInt) String() string { return fmt.Sprintf("[%d]th", mi) } ​ type MyStr string ​ func (ms MyStr) String() string { return string(ms) + "!!!" } func main() { intSlice := []MyInt{1, 2, 3, 4} // compile error, []MyInt not match []fmt.Stringer fmt.Printf("%v convert %v\n", intSlice, ConvertSliceToStrSlice(intSlice)) ​ ​ strSlice := []MyStr{"111", "222", "333"} fmt.Printf("%v convert %v\n", strSlice, ConvertSliceToStrSlice(strSlice)) // output //[[1]th [2]th [3]th [4]th] convert [[1]th [2]th [3]th [4]th] //[111!!! 222!!! 333!!!] convert [111!!! 222!!! 333!!!] } 简单吧，在 StringConstraint 约束中定义一个 String() string，这样只要有这个方法的类型都可以作为 T 在 ConvertSliceToStrSlice 使用。在这个约束条件下，所有具有 String() string 方法的类型都可以进行转换，但是我们如果想把约束条件定的更加苛刻，例如只有底层类型为 int 或者 string 的类型才可以调用这个函数。 那么我们可以进一步在 StringConstraint 中添加约束条件： type StringConstraint interface { type int, string String() string } 这样满足这个约束的类型集合就是底层类型是 int 或者 string，并且，具有 String() string 方法的类型。而这个类型集合就是 type int, string 的类型集合与 String() string 的类型集合的交集。具体的概念后续介绍。 这样，MyFloat、MyUint 就无法调用 ConvertSliceToStrSlice 这个函数了。 package main ​ import ( "fmt" ) ​ type StringConstraint interface { type int, string String() string } ​ func ConvertSliceToStrSlice[T StringConstraint](input []T) []string { output := make([]string, 0, len(input)) for _, item := range input { output = append(output, item.String()) } return output } ​ type MyFloat float64 ​ func (mf MyFloat) String() string { return fmt.Sprintf("%fth", mf) } ​ type MyInt int ​ func (mi MyInt) String() string { return fmt.Sprintf("[%d]th", mi) } ​ type MyStr string ​ func (ms MyStr) String() string { return string(ms) + "!!!" } func main() { intSlice := []MyInt{1, 2, 3, 4} // compile error, []MyInt not match []fmt.Stringer fmt.Printf("%v convert %v\n", intSlice, ConvertSliceToStrSlice(intSlice)) ​ strSlice := []MyStr{"111", "222", "333"} fmt.Printf("%v convert %v\n", strSlice, ConvertSliceToStrSlice(strSlice)) // output //[[1]th [2]th [3]th [4]th] convert [[1]th [2]th [3]th [4]th] //[111!!! 222!!! 333!!!] convert [111!!! 222!!! 333!!!] floatSlice := []MyFloat{1.1, 2.2, 3.3} //type checking failed for main //prog.go2:48:44: MyFloat does not satisfy StringConstraint (MyFloat or float64 not found in int, string) ​ fmt.Printf("%v convert %v\n", floatSlice, ConvertSliceToStrSlice(floatSlice)) } 小结： 总的来说，泛型可以简化代码的编写，同时在编译时进行类型检查，如果类型不满足约束，就会在编译时报错；这样就避免了运行时不可控的错误了。 到此这篇关于Go 泛型和非泛型代码详解的文章就介绍到这了,更多相关Go 泛型和非泛型代码内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

结构体类型可以用来保存不同类型的数据，也可以通过方法的形式来声明它的行为。本文将介绍go语言中的结构体和方法，以及“继承”的实现方法。 结构体类型 结构体类型（struct）在go语言中具有重要地位，它是实现go语言面向对象编程的重要工具。go语言中没有类的概念，可以使用结构体实现类似的功能，传统的OOP（Object-Oriented Programming）思想中的继承在go中可以通过嵌入字段的方式实现。 结构体的声明与定义： // 使用关键字 type 和 struct 定义名字为Person结构体 type Robot struct { name string height int } 初始化及赋值： // 通过var声明 var r1 Robot r1.name = "Optimus Prime" // 字面量直接赋值 r2 := Robot{name: "Optimus Prime"} r3 := Robot{"Optimus Prime", 100} //如果不加字段名，值必须按定义顺序给出 // new 函数 r4 := new(Robot) r4.name = "Optimus Prime" //或者 r5 := &Robot{} r5.name = r1.name 方法 go语言中的函数和方法是有区别的，方法必须有名字，必须隶属于某一个类型，这个类型通过方法声明中的接收者（receiver）声明定义。 接收者声明位于关键字func和方法名称之间的圆括号中，必须包含确切的名称和类型字面量。 类型就是当前方法所属的类型 名称用于当前方法中引用它所属类型的值 package main import "fmt" type Robot struct { name string height int } func (r Robot) String() string{ return fmt.Sprintf("name: %s, height: %d",r.name, r.height) } func main() { r1 := Robot{name: "Optimus Prime", height: 100} fmt.Println(r1) // 结果： name: Optimus Prime, height: 100 } 从String()方法的接收者声明可以看出它隶属于Robot类型，接收者名称为r。 结构体内嵌：“继承”与“重写” Go 语言中没有继承的概念，具体原因和理念可参考官网：Why is there no type inheritance? go语言可以通过嵌入字段来实现类似继承的效果，来看下面的代码： package main import "fmt" type Skills struct { speak string } func (s Skills) Speak() { fmt.Println(s.speak) } type Robot struct { name string // 姓名 height int // 身高 Skills } func main() { skill := Skills{speak: "hello !"} skill.Speak() robot := Robot{ name: "Optimus Prime", Skills: skill, } robot.Speak() } 嵌入字段的方法集合会被合并到被嵌入类型的方法集合中。上面代码中，robot.Speak() 会调用嵌入字段Skills的Speak()方法，类似于继承了Skills的Speak()方法。执行结果如下： hello ! hello ! 下面添加一个Robot类型的Speak()方法： func (r Robot) Speak() { fmt.Printf("My name is %s, ",r.name) r.Skills.Speak() } 那么再次执行，会执行哪个Speak()方法呢？答案是Robot类型的Speak()方法，嵌入字段Skills的Speak()方法被“屏蔽”了，也就是说，被嵌入类型的方法覆盖了嵌入字段的同名方法，这与方法重写类似。 执行结果： hello ! My name is Optimus Prime, hello ! 可以通过链式的选择表达式，选择到嵌入字段的字段或方法，r.Skills.Speak() 就调用了嵌入字段Skills的Speak()方法。 总结 需要注意的是Go 语言虽然支持面向对象编程，但是它没有继承的概念，可以通过嵌入字段的方式来实现类似继承的功能，这种组合方法相比多重继承更加简洁。 到此这篇关于Go语言基础语法之结构体及方法详解的文章就介绍到这了,更多相关Go结构体及方法内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1.前言 虽然在 go 中，并发编程十分简单， 只需要使用 go func() 就能启动一个 goroutine 去做一些事情，但是正是由于这种简单我们要十分当心，不然很容易出现一些莫名其妙的 bug 或者是你的服务由于不知名的原因就重启了。 而最常见的bug是关于线程安全方面的问题，比如对同一个map进行写操作。 2.数据竞争 线程安全是否有什么办法检测到呢？ 答案就是 data race tag，go 官方早在 1.1 版本就引入了数据竞争的检测工具，我们只需要在执行测试或者是编译的时候加上 -race 的 flag 就可以开启数据竞争的检测 使用方式如下 go test -race main.go go build -race 不建议在生产环境 build 的时候开启数据竞争检测，因为这会带来一定的性能损失(一般内存5-10倍，执行时间2-20倍)，当然 必须要 debug 的时候除外。 建议在执行单元测试时始终开启数据竞争的检测 2.1 示例一 执行如下代码，查看每次执行的结果是否一样 2.1.1 测试 代码 package main import ( "fmt" "sync" ) var wg sync.WaitGroup var counter int func main() { // 多跑几次来看结果 for i := 0; i < 100000; i++ { run() } fmt.Printf("Final Counter: %d\n", counter) } func run() { // 开启两个 协程，操作 for i := 1; i <= 2; i++ { wg.Add(1) go routine(i) } wg.Wait() } func routine(id int) { for i := 0; i < 2; i++ { value := counter value++ counter = value } wg.Done() } 执行三次查看结果，分别是 Final Counter: 399950 Final Counter: 399989 Final Counter: 400000 原因分析：每一次执行的时候，都使用 go routine(i) 启动了两个 goroutine，但是并没有控制它的执行顺序，并不能满足顺序一致性内存模型。 当然由于种种不确定性，所有肯定不止这两种情况， 2.1.2 data race 检测 上面问题的出现在上线后如果出现bug会非常难定位，因为不知道到底是哪里出现了问题，所以我们就要在测试阶段就结合 data race 工具提前发现问题。 使用 go run -race ./main.go 输出: 运行结果发现输出记录太长，调试的时候并不直观，结果如下 main.main()       D:/gopath/src/Go_base/daily_test/data_race/demo.go:14 +0x44 ================== Final Counter: 399987 Found 1 data race(s) exit status 66 2.1.3 data race 配置 在官方的文档当中，可以通过设置 GORACE 环境变量，来控制 data race 的行为， 格式如下: GORACE="option1=val1 option2=val2" 可选配置见下表 配置 GORACE="halt_on_error=1 strip_path_prefix=/mnt/d/gopath/src/Go_base/daily_test/data_race/01_data_race" go run -race ./demo.go 输出： ================== WARNING: DATA RACE Read at 0x00000064d9c0 by goroutine 8:   main.routine()       /mnt/d/gopath/src/Go_base/daily_test/data_race/demo.go:31 +0x47   Previous write at 0x00000064d9c0 by goroutine 7:   main.routine()       /mnt/d/gopath/src/Go_base/daily_test/data_race/demo.go:33 +0x64   Goroutine 8 (running) created at:   main.run()       /mnt/d/gopath/src/Go_base/daily_test/data_race/demo.go:24 +0x75   main.main()       /mnt/d/gopath/src/Go_base/daily_test/data_race/demo.go:14 +0x3c   Goroutine 7 (finished) created at:   main.run()       /mnt/d/gopath/src/Go_base/daily_test/data_race/demo.go:24 +0x75   main.main()       /mnt/d/gopath/src/Go_base/daily_test/data_race/demo.go:14 +0x3c ================== exit status 66 说明:结果告诉可以看出 31 行这个地方有一个 goroutine 在读取数据，但是呢，在 33 行这个地方又有一个 goroutine 在写入，所以产生了数据竞争。 然后下面分别说明这两个 goroutine 是什么时候创建的，已经当前是否在运行当中。 2.2 循环中使用goroutine引用临时变量 代码如下： func main() { var wg sync.WaitGroup wg.Add(5) for i := 0; i < 5; i++ { go func() { fmt.Println(i) wg.Done() }() } wg.Wait() } 输出：常见的答案就是会输出 5 个 5，因为在 for 循环的 i++ 会执行的快一些，所以在最后打印的结果都是 5 这个答案不能说不对，因为真的执行的话大概率也是这个结果，但是不全。因为这里本质上是有数据竞争，在新启动的 goroutine 当中读取 i 的值，在 main 中写入，导致出现了 data race，这个结果应该是不可预知的，因为我们不能假定 goroutine 中 print 就一定比外面的 i++ 慢，习惯性的做这种假设在并发编程中是很有可能会出问题的 正确示例：将 i 作为参数传入即可，这样每个 goroutine 拿到的都是拷贝后的数据 func main() { var wg sync.WaitGroup wg.Add(5) for i := 0; i < 5; i++ { go func(i int) { fmt.Println(i) wg.Done() }(i) } wg.Wait() } 2.3 引起变量共享 代码 package main import "os" func main() { ParallelWrite([]byte("xxx")) } // ParallelWrite writes data to file1 and file2, returns the errors. func ParallelWrite(data []byte) chan error { res := make(chan error, 2) // 创建/写入第一个文件 f1, err := os.Create("/tmp/file1") if err != nil { res <- err } else { go func() { // 下面的这个函数在执行时，是使用err进行判断，但是err的变量是个共享的变量 _, err = f1.Write(data) res <- err f1.Close() }() } // 创建写入第二个文件n f2, err := os.Create("/tmp/file2") if err != nil { res <- err } else { go func() { _, err = f2.Write(data) res <- err f2.Close() }() } return res } 分析： 使用 go run -race main.go 执行，可以发现这里报错的地方是，21 行和 28 行，有 data race，这里主要是因为共享了 err 这个变量 root@failymao:/mnt/d/gopath/src/Go_base/daily_test/data_race# go run -race demo2.go ================== WARNING: DATA RACE Write at 0x00c0001121a0 by main goroutine: main.ParallelWrite() /mnt/d/gopath/src/Go_base/daily_test/data_race/demo2.go:28 +0x1dd main.main() /mnt/d/gopath/src/Go_base/daily_test/data_race/demo2.go:6 +0x84 Previous write at 0x00c0001121a0 by goroutine 7: main.ParallelWrite.func1() /mnt/d/gopath/src/Go_base/daily_test/data_race/demo2.go:21 +0x94 Goroutine 7 (finished) created at: main.ParallelWrite() /mnt/d/gopath/src/Go_base/daily_test/data_race/demo2.go:19 +0x336 main.main() /mnt/d/gopath/src/Go_base/daily_test/data_race/demo2.go:6 +0x84 ================== Found 1 data race(s) exit status 66 修正： 在两个goroutine中使用新的临时变量 _, err := f1.Write(data) ... _, err := f2.Write(data) ... 2.4 不受保护的全局变量 所谓全局变量是指，定义在多个函数的作用域之外，可以被多个函数或方法进行调用，常用的如 map数据类型 // 定义一个全局变量 map数据类型 var service = map[string]string{} // RegisterService RegisterService // 用于写入或更新key-value func RegisterService(name, addr string) { service[name] = addr } // LookupService LookupService // 用于查询某个key-value func LookupService(name string) string { return service[name] } 要写出可测性比较高的代码就要少用或者是尽量避免用全局变量，使用 map 作为全局变量比较常见的一种情况就是配置信息。关于全局变量的话一般的做法就是加锁，或者也可以使用 sync.Ma var ( service map[string]string serviceMu sync.Mutex ) func RegisterService(name, addr string) { serviceMu.Lock() defer serviceMu.Unlock() service[name] = addr } func LookupService(name string) string { serviceMu.Lock() defer serviceMu.Unlock() return service[name] } 2.5 未受保护的成员变量 一般讲成员变量 指的是数据类型为结构体的某个字段。 如下一段代码 type Watchdog struct{ last int64 } func (w *Watchdog) KeepAlive() { // 第一次进行赋值操作 w.last = time.Now().UnixNano() } func (w *Watchdog) Start() { go func() { for { time.Sleep(time.Second) // 这里在进行判断的时候，很可能w.last更新正在进行 if w.last < time.Now().Add(-10*time.Second).UnixNano() { fmt.Println("No keepalives for 10 seconds. Dying.") os.Exit(1) } } }() } 使用原子操作atomiic type Watchdog struct{ last int64 } func (w *Watchdog) KeepAlive() { // 修改或更新 atomic.StoreInt64(&w.last, time.Now().UnixNano()) } func (w *Watchdog) Start() { go func() { for { time.Sleep(time.Second) // 读取 if atomic.LoadInt64(&w.last) < time.Now().Add(-10*time.Second).UnixNano() { fmt.Println("No keepalives for 10 seconds. Dying.") os.Exit(1) } } }() } 2.6 接口中存在的数据竞争 一个很有趣的例子 Ice cream makers and data races package main import "fmt" type IceCreamMaker interface { // Great a customer. Hello() } type Ben struct { name string } func (b *Ben) Hello() { fmt.Printf("Ben says, \"Hello my name is %s\"\n", b.name) } type Jerry struct { name string } func (j *Jerry) Hello() { fmt.Printf("Jerry says, \"Hello my name is %s\"\n", j.name) } func main() { var ben = &Ben{name: "Ben"} var jerry = &Jerry{"Jerry"} var maker IceCreamMaker = ben var loop0, loop1 func() loop0 = func() { maker = ben go loop1() } loop1 = func() { maker = jerry go loop0() } go loop0() for { maker.Hello() } } 这个例子有趣的点在于，最后输出的结果会有这种例子 Ben says, "Hello my name is Jerry" Ben says, "Hello my name is Jerry" 这是因为我们在maker = jerry这种赋值操作的时候并不是原子的，在上一篇文章中我们讲到过，只有对 single machine word 进行赋值的时候才是原子的，虽然这个看上去只有一行，但是 interface 在 go 中其实是一个结构体，它包含了 type 和 data 两个部分，所以它的复制也不是原子的，会出现问题 type interface struct { Type uintptr // points to the type of the interface implementation Data uintptr // holds the data for the interface's receiver } 这个案例有趣的点还在于，这个案例的两个结构体的内存布局一模一样所以出现错误也不会 panic 退出，如果在里面再加入一个 string 的字段，去读取就会导致 panic，但是这也恰恰说明这个案例很可怕，这种错误在线上实在太难发现了，而且很有可能会很致命。 3. 总结 使用 go build -race main.go和go test -race ./ 可以测试程序代码中是否存在数据竞争问题 善用 data race 这个工具帮助我们提前发现并发错误 不要对未定义的行为做任何假设，虽然有时候我们写的只是一行代码，但是 go 编译器可能后面做了很多事情，并不是说一行写完就一定是原子的 即使是原子的出现了 data race 也不能保证安全，因为我们还有可见性的问题，上篇我们讲到了现代的 cpu 基本上都会有一些缓存的操作。 所有出现了 data race 的地方都需要进行处理 4 参考 https://lailin.xyz/post/go-training-week3-data-race.html#典型案例 https://dave.cheney.net/2014/06/27/ice-cream-makers-and-data-races http://blog.golang.org/race-detector https://golang.org/doc/articles/race_detector.html https://dave.cheney.net/2018/01/06/if-aligned-memory-writes-are-atomic-why-do-we-need-the-sync-atomic-package 到此这篇关于Go并发编程实现数据竞争的文章就介绍到这了,更多相关Go 数据竞争内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

使用JWT进行认证 JSON Web Tokens (JWT) are a more modern approach to authentication. As the web moves to a greater separation between the client and server, JWT provides a wonderful alternative to traditional cookie based authentication models. JWTs provide a way for clients to authenticate every request without having to maintain a session or repeatedly pass login credentials to the server. 用户注册之后, 服务器生成一个 JWT token返回给浏览器, 浏览器向服务器请求数据时将 JWT token 发给服务器, 服务器用 signature 中定义的方式解码 JWT 获取用户信息. 一个 JWT token包含3部分: 1 header: 告诉我们使用的算法和 token 类型 2 Payload: 必须使用 sub key 来指定用户 ID, 还可以包括其他信息比如 email, username 等. 3 Signature: 用来保证 JWT 的真实性. 可以使用不同算法 package main import ( "encoding/json" "fmt" "log" "net/http" "strings" "time" "github.com/codegangsta/negroni" "github.com/dgrijalva/jwt-go" "github.com/dgrijalva/jwt-go/request" ) const ( SecretKey = "welcome ---------" ) func fatal(err error) { if err != nil { log.Fatal(err) } } type UserCredentials struct { Username string `json:"username"` Password string `json:"password"` } type User struct { ID int `json:"id"` Name string `json:"name"` Username string `json:"username"` Password string `json:"password"` } type Response struct { Data string `json:"data"` } type Token struct { Token string `json:"token"` } func StartServer() { http.HandleFunc("/login", LoginHandler) http.Handle("/resource", negroni.New( negroni.HandlerFunc(ValidateTokenMiddleware), negroni.Wrap(http.HandlerFunc(ProtectedHandler)), )) log.Println("Now listening...") http.ListenAndServe(":8087", nil) } func main() { StartServer() } func ProtectedHandler(w http.ResponseWriter, r *http.Request) { response := Response{"Gained access to protected resource"} JsonResponse(response, w) } func LoginHandler(w http.ResponseWriter, r *http.Request) { var user UserCredentials err := json.NewDecoder(r.Body).Decode(&user) if err != nil { w.WriteHeader(http.StatusForbidden) fmt.Fprint(w, "Error in request") return } if strings.ToLower(user.Username) != "someone" { if user.Password != "p@ssword" { w.WriteHeader(http.StatusForbidden) fmt.Println("Error logging in") fmt.Fprint(w, "Invalid credentials") return } } token := jwt.New(jwt.SigningMethodHS256) claims := make(jwt.MapClaims) claims["exp"] = time.Now().Add(time.Hour * time.Duration(1)).Unix() claims["iat"] = time.Now().Unix() token.Claims = claims if err != nil { w.WriteHeader(http.StatusInternalServerError) fmt.Fprintln(w, "Error extracting the key") fatal(err) } tokenString, err := token.SignedString([]byte(SecretKey)) if err != nil { w.WriteHeader(http.StatusInternalServerError) fmt.Fprintln(w, "Error while signing the token") fatal(err) } response := Token{tokenString} JsonResponse(response, w) } func ValidateTokenMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) { token, err := request.ParseFromRequest(r, request.AuthorizationHeaderExtractor, func(token *jwt.Token) (interface{}, error) { return []byte(SecretKey), nil }) if err == nil { if token.Valid { next(w, r) } else { w.WriteHeader(http.StatusUnauthorized) fmt.Fprint(w, "Token is not valid") } } else { w.WriteHeader(http.StatusUnauthorized) fmt.Fprint(w, "Unauthorized access to this resource") } } func JsonResponse(response interface{}, w http.ResponseWriter) { json, err := json.Marshal(response) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.WriteHeader(http.StatusOK) w.Header().Set("Content-Type", "application/json") w.Write(json) } 到此这篇关于golang进行简单权限认证的实现的文章就介绍到这了,更多相关Golang 权限认证内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

       部门产品业务功能采用Golang开发，但是有些功能是用c写的，比如说net-snmp，bfd协议等等，像这些如果使用GO语言重编的话，既有实现的复杂度也需要相当长的时间，好在GO语言提供了CGO机制，使得能够在go代码中直接调用C的库函数，大大提高了效率，减少了重复开发工作,此外还支持在C语言中调用GO函数，这一点还是蛮强大的。 1. Go语言调用C函数例子： package main // // 引用的C头文件需要在注释中声明，紧接着注释需要有import "C"，且这一行和注释之间不能有空格 // /* #include <stdio.h> #include <stdlib.h> #include <unistd.h> void myprint(char* s) { printf("%s\n", s); } */ import "C" import ( "fmt" "unsafe" ) func main() { //使用C.CString创建的字符串需要手动释放。 cs := C.CString("Hello World\n") C.myprint(cs) C.free(unsafe.Pointer(cs)) fmt.Println("call C.sleep for 3s") C.sleep(3) return } 运行： 2. Go语言调用C库函数： hello.c #include <stdio.h> void hello() { printf("hello world\n"); } hello.h #ifndef HELLO_H #define HELLO_H void hello(void); #endif 编译： gcc -c hello.c ar -cru libhello.a hello.o package main //使用#cgo定义库路径 /* #cgo CFLAGS: -I . #cgo LDFLAGS: -L . -lhello #include "hello.h" */ import "C" func main() { C.hello() } 运行： 3. Go语言导出函数给C语言使用： main.go package main // //#include <stdio.h> //int add(int a, int b); // import "C" import ( "fmt" ) //当使用export的时候，在同一个文件中就不能再定义其它的c函数了，不然会报错。 //使用export导出函数给c语言调用。 //export GoAdd func GoAdd(a, b int) int { return a + b } func main() { a := C.add(1, 2) fmt.Printf("C.add(1,2) return %d\n", a) } cfunc.go package main // //int GoAdd(int a, int b); // //int add(int a, int b) //{ // return GoAdd(a,b); //} // import "C" 运行： 4. Go语言导出函数指针给c语言使用： 还有一种使用方式，这种是我使用比较多的。就是传递函数指针，因为GO函数无法取址，因此需要写个中间函数做个转换操作，例子如下： clibrary.c #include <stdio.h> #include "clibrary.h" //参数是函数指针 void some_c_func(callback_fcn callback) { int arg = 2; printf("C.some_c_func(): calling callback with arg = %d\n", arg); int response = callback(2); printf("C.some_c_func(): callback responded with %d\n", response); }  clibrary.h #ifndef CLIBRARY_H #define CLIBRARY_H //定义函数指针 typedef int (*callback_fcn)(int); void some_c_func(callback_fcn); #endif Go code: package main /* #cgo CFLAGS: -I . #cgo LDFLAGS: -L . -lclibrary #include "clibrary.h" int callOnMeGo_cgo(int in); // 声明 */ import "C" import ( "fmt" "unsafe" ) //export callOnMeGo func callOnMeGo(in int) int { return in + 1 } func main() { fmt.Printf("Go.main(): calling C function with callback to us\n") //使用unsafe.Pointer转换 C.some_c_func((C.callback_fcn)(unsafe.Pointer(C.callOnMeGo_cgo))) } 中间函数： package main /* #include <stdio.h> int callOnMeGo(int); // The gateway function int callOnMeGo_cgo(int in) { printf("C.callOnMeGo_cgo(): called with arg = %d\n", in); //调用GO函数 return callOnMeGo(in); } */ import "C" 运行： 开发注意事项： 1. 在注释和import”C”之间不能有空行 2. 使用C.CString函数转换GoString为CString时要手动释放该字符串。 3. CGO不支持使用变参的函数，例如printf,如果要使用的话，可以写个包裹函数m'yprintf,使用传参的方式调用。 4. Go支持使用//export导出函数给C使用，但是有一点需要注意就是不能在export导出的同一个文件里定义c函数，不然会出现 multiple definition of "xxx"编译错误，如果函数非常tiny的话，还有一个方法是使用static inline 来声明该函数，如下： package gocallback import ( "fmt" "sync" ) /* extern void go_callback_int(int foo, int p1); // normally you will have to define function or variables // in another separate C file to avoid the multiple definition // errors, however, using "static inline" is a nice workaround // for simple functions like this one. static inline void CallMyFunction(int foo) { go_callback_int(foo, 5); } */ import "C" 参考资料： 1. https://github.com/golang/go/wiki/cgo 到此这篇关于Go语言中CGo的使用实践的文章就介绍到这了,更多相关Go语言使用CGO内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

yaml文件内容 apiVersion: policy/v1beta1 kind: PodSecurityPolicy metadata: name: mysql-snapshot spec: privileged: false allowPrivilegeEscalation: false volumes: - "*" hostNetwork: false hostIPC: false hostPID: false runAsUser: rule: RunAsAny seLinux: rule: RunAsAny supplementalGroups: rule: RunAsAny fsGroup: rule: RunAsAny 示例代码：实现了base64 编解码、yaml转map、以及map遍历 func main() { f, err := os.Open("cmd/test.yaml") if err != nil { log.Fatalln(err) return } input, _ := ioutil.ReadAll(f) // base64 编码 encodeString := base64.StdEncoding.EncodeToString(input) fmt.Println(encodeString) // base64 解码 decodeBytes, err := base64.StdEncoding.DecodeString(encodeString) if err != nil { log.Fatalln(err) } //yaml文件内容转换成map[interface{}]interface{}) resultMap := make(map[interface{}]interface{}) if err := yaml.Unmarshal(decodeBytes, &resultMap); err != nil { // error handling log.Fatalln(err) } // 遍历map ，此处取metadata.name值 for key, value := range resultMap { switch key := key.(type) { case string: if key == "metadata" { switch value := value.(type) { case string: case map[interface{}]interface{}: for k, v := range value { switch k.(type) { case string: if k == "name" { fmt.Println("value=", v) } } } } } } } } 结果 encodeString = "YXBpVmVyc2lvbjogcG9saWN5L3YxYmV0YTEKa2luZDogUG9kU2VjdXJpdHlQb2xpY3kKbWV0YWRhdGE6CiAgbmFtZTogbXlzcWwtc25hcHNob3QKc3BlYzogCiAgcHJpdmlsZWdlZDogZmFsc2UKICBhbGxvd1ByaXZpbGVnZUVzY2FsYXRpb246IGZhbHNlCiAgdm9sdW1lczoKICAtICIqIgogIGhvc3ROZXR3b3JrOiBmYWxzZQogIGhvc3RJUEM6IGZhbHNlCiAgaG9zdFBJRDogZmFsc2UKICBydW5Bc1VzZXI6CiAgICBydWxlOiBSdW5Bc0FueQogIHNlTGludXg6CiAgICBydWxlOiBSdW5Bc0FueQogIHN1cHBsZW1lbnRhbEdyb3VwczoKICAgIHJ1bGU6IFJ1bkFzQW55CiAgZnNHcm91cDoKICAgIHJ1bGU6IFJ1bkFzQW55Cg==" value=mysql-snapshot 到此这篇关于go语言yaml转map、map遍历的实现的文章就介绍到这了,更多相关Go语言yaml转map、map遍历内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、什么是MQTT MQTT（Message Queuing Telemetry Transport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的“轻量级”通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。 MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联网、小型设备、移动应用等方面有较广泛的应用 MQTT是一个基于客户端-服务器的消息发布/订阅传输协议。MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT）。其在，通过卫星链路通信传感器、偶尔拨号的医疗设备、智能家居、及一些小型化设备中已广泛使用 MQTT还有一个特点就是客户端之间不用相互通信, MQTT通信更像是邮箱服务，发布者发布消息到服务器，接收者只要订阅了其服务在线后即可收到 实现MQTT协议需要客户端和服务器端通讯完成，在通讯过程中，MQTT协议中有三种身份：发布者（Publish）、代理（Broker）（服务器）、订阅者（Subscribe）。其中，消息的发布者和订阅者都是客户端，消息代理是服务器，消息发布者可以同时是订阅者。 MQTT传输的消息分为：主题（Topic）和负载（payload）两部分： （1）Topic，可以理解为消息的类型，订阅者订阅（Subscribe）后，就会收到该主题的消息内容（payload）； （2）payload，可以理解为消息的内容，是指订阅者具体要使用的内容。 Topic就是消息名，payload就是消息体 MQTT会构建底层网络传输：它将建立客户端到服务器的连接，提供两者之间的一个有序的、无损的、基于字节流的双向传输。 当应用数据通过MQTT网络发送时，MQTT会把与之相关的**服务质量（QoS）和主题名（Topic）**相关连。 二、Go语言MQTT服务器Broker的搭建 服务端用erlang编写的一个开源项目：emqqtd # 下载安装包 wget https://github.com/emqx/emqx/releases/download/v4.0.4/emqx-ubuntu18.04-v4.0.4.zip cd mqttd/emqx . ├── bin ├── data ├── erts-10.5.2 ├── etc ├── lib ├── log └── releases # 开启服务 ./bin/emqx start # 查看状态 ./bin/emqx_ctl status # 停止服务 ./bin/emqx stop 找到自己的IP，访问http://[你的IP]:18083/#/clients 用户名：admin 密码：public 即可进入服务器的控制台 三、Go客户端访问简单API 客户端用golang客户端的库：“github.com/eclipse/paho.mqtt.golang” # 下载依赖包 go get -u github.com/eclipse/paho.mqtt.golang 实例如下： 编写了两个函数一个发布一个订阅，传入参数即可服务 修改EMQServerAddress为你服务器的IP package main // 与后端mqtt服务交互 import ( "fmt" mqtt "github.com/eclipse/paho.mqtt.golang" "log" "os" "strconv" "time" ) const EMQServerAddress = "你的IP" // 创建全局mqtt publish消息处理 handler var messagePubHandler mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) { fmt.Println("Push Message:") fmt.Printf("TOPIC: %s\n", msg.Topic()) fmt.Printf("MSG: %s\n", msg.Payload()) } // 创建全局mqtt sub消息处理 handler var messageSubHandler mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) { fmt.Println("收到订阅消息:") fmt.Printf("Sub Client Topic : %s \n", msg.Topic()) fmt.Printf("Sub Client msg : %s \n", msg.Payload()) } // 连接的回掉函数 var connectHandler mqtt.OnConnectHandler =func(client mqtt.Client) { fmt.Println("新的连接!" + " Connected") } // 丢失连接的回掉函数 var connectLostHandler mqtt.ConnectionLostHandler = func(client mqtt.Client, err error) { fmt.Printf("Connect loss: %v\n", err) } func init() { // 配置错误提示 mqtt.DEBUG = log.New(os.Stdout, " [mqttDEBUG]", 0) mqtt.ERROR = log.New(os.Stdout, " [mqttERROR]", 0) } /** * @Description: 发布订阅 * @param clientID * @param addr * @param topic * @param payload */ func Push(topic string, qos byte, retain bool, payload string) { // opts ClientOptions 用于设置 broker，端口，客户端 id ，用户名密码等选项 opts := mqtt.NewClientOptions().AddBroker("tcp://" + EMQServerAddress + ":1883").SetClientID("test_push") opts.SetKeepAlive(60 * time.Second) // Message callback handler，在没有任何订阅时，发布端调用此函数 opts.SetDefaultPublishHandler(messagePubHandler) opts.SetPingTimeout(1 * time.Second) opts.OnConnect = connectHandler opts.OnConnectionLost = connectLostHandler client := mqtt.NewClient(opts) if token := client.Connect(); token.Wait() && token.Error() != nil { panic(token.Error()) } //发布消息 // qos是服务质量: ==1: 一次, >=1: 至少一次, <=1:最多一次 // retained: 表示mqtt服务器要保留这次推送的信息，如果有新的订阅者出现，就会把这消息推送给它（持久化推送） token := client.Publish(topic, qos, retain, payload) token.Wait() fmt.Println("Push Data : "+topic, "Data Size is "+strconv.Itoa(len(payload))) fmt.Println("Disconnect with broker") client.Disconnect(250) } /** * @Description: 订阅与取消订阅 * @param clientID * @param addr * @param topic * @param isSub */ func Subscription(topic string, qos byte, isSub bool, handleFun func([]byte)) { opts := mqtt.NewClientOptions().AddBroker("tcp://" + EMQServerAddress + ":1883").SetClientID("sub_test") opts.SetKeepAlive(60 * time.Second) opts.SetPingTimeout(1 * time.Second) opts.OnConnect = func(client mqtt.Client) { fmt.Println("New Subscription! Connected" + " => " + topic) } opts.OnConnectionLost = connectLostHandler client := mqtt.NewClient(opts) if token := client.Connect(); token.Wait() && token.Error() != nil { panic(token.Error()) } if isSub { // 订阅消息 if token := client.Subscribe(topic, qos, func(client mqtt.Client, msg mqtt.Message) { fmt.Printf("Receive Subscribe Message :") fmt.Printf("Sub Client Topic : %s, Data size is %d \n", msg.Topic(), len(msg.Payload())) if len(msg.Payload()) > 0 { handleFun(msg.Payload()) } }); token.Wait() && token.Error() != nil { fmt.Println(token.Error()) os.Exit(1) } } else { // 取消订阅 if token := client.Unsubscribe(topic); token.Wait() && token.Error() != nil { fmt.Println(token.Error()) os.Exit(1) } } } 学习资料： https://studygolang.com/articles/14452 https://blog.csdn.net/jacky128256/article/details/105610456 到此这篇关于go语言实现mqtt协议的实践的文章就介绍到这了,更多相关Go语言 mqtt协议内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言 Go的错误处理这块是日常被大家吐槽较多的地方，我在工作中也观察到一些现象，比较严重的是在各层级的逻辑代码中对错误的处理有些重复。比如，有人写代码就会在每一层都判断错误并记录日志，从代码层面看，貌似很严谨，但是如果看日志会发现一堆重复的信息，等到排查问题时反而会造成干扰。 今天给大家总结三点Go代码错误处理相关的最佳实践给大家。 这些最佳实践也是网上一些前辈分享的，我自己实践后在这里用自己的语言描述出来，希望能对大家有所帮助。 认识error Go程序通过error类型的值表示错误 error类型是一个内建接口类型，该接口只规定了一个返回字符串值的Error方法。 type error interface { Error() string } Go语言的函数经常会返回一个error值，调用者通过测试error值是否是nil来进行错误处理。 i, err := strconv.Atoi("42") if err != nil { fmt.Printf("couldn't convert number: %v\n", err) return } fmt.Println("Converted integer:", i) error为nil时表示成功；非nil的error表示失败。 自定义错误记得要实现error接口 我们经常会定义符合自己需要的错误类型，但是记住要让这些类型实现error接口，这样就不用在调用方的程序里引入额外的类型。 比如下面我们自己定义了myError这个类型，如果不实现error接口的话，调用者的代码中就会被myError这个类型侵入。比如下面的run函数，在定义返回值类型时，直接定义成error即可。 package myerror import ( "fmt" "time" ) type myError struct { Code int When time.Time What string } func (e *myError) Error() string { return fmt.Sprintf("at %v, %s, code %d", e.When, e.What, e.Code) } func run() error { return &MyError{ 1002, time.Now(), "it didn't work", } } func TryIt() { if err := run(); err != nil { fmt.Println(err) } } 如果myError不实现error接口的话，这里的返回值类型就要定义成myError类型。可想而知，紧接着调用者的程序里就要通过myError.Code == xxx 来判断到底是哪种具体的错误（当然想要这么干得先把myError改成导出的MyError）。 那调用者判断自定义error是具体哪种错误的时候应该怎么办呢，myError并未向包外暴露，答案是通过向包外暴露检查错误行为的方法来实现。 myerror.IsXXXError(err) ... 抑或是通过比较error本身与包向外暴露的常量错误是否相等来判断，比如操作文件时常用来判断文件是否结束的io.EOF。 类似的还有gorm.ErrRecordNotFound等各种开源包对外暴露的错误常量。 if err != io.EOF { return err } 错误处理常犯的错误 先看一段简单的程序，看大家能不能发现一些细微的问题 func WriteAll(w io.Writer, buf []byte) error { _, err := w.Write(buf) if err != nil { log.Println("unable to write:", err) // annotated error goes to log file return err // unannotated error returned to caller } return nil } func WriteConfig(w io.Writer, conf *Config) error { buf, err := json.Marshal(conf) if err != nil { log.Printf("could not marshal config: %v", err) return err } if err := WriteAll(w, buf); err != nil { log.Println("could not write config: %v", err) return err } return nil } func main() { err := WriteConfig(f, &conf) fmt.Println(err) // io.EOF } 错误处理常犯的两个问题 上面程序的错误处理暴露了两个问题： 1.底层函数WriteAll在发生错误后，除了向上层返回错误外还向日志里记录了错误，上层调用者做了同样的事情，记录日志然后把错误再返回给程序顶层。 因此在日志文件中得到一堆重复的内容 unable to write: io.EOF could not write config: io.EOF ... 2. 在程序的顶部，虽然得到了原始错误，但没有相关内容，换句话说没有把WriteAll、WriteConfig记录到 log 里的那些信息包装到错误里，返回给上层。 针对这两个问题的解决方案可以是，在底层函数WriteAll、WriteConfig中为发生的错误添加上下文信息，然后将错误返回上层，由上层程序最后处理这些错误。 一种简单的包装错误的方法是使用fmt.Errorf函数，给错误添加信息。 func WriteConfig(w io.Writer, conf *Config) error { buf, err := json.Marshal(conf) if err != nil { return fmt.Errorf("could not marshal config: %v", err) } if err := WriteAll(w, buf); err != nil { return fmt.Errorf("could not write config: %v", err) } return nil } func WriteAll(w io.Writer, buf []byte) error { _, err := w.Write(buf) if err != nil { return fmt.Errorf("write failed: %v", err) } return nil } 给错误附加上下文信息 fmt.Errorf只是给错误添加了简单的注解信息，如果你想在添加信息的同时还加上错误的调用栈，可以借助github.com/pkg/errors这个包提供的错误包装能力。 //只附加新的信息 func WithMessage(err error, message string) error //只附加调用堆栈信息 func WithStack(err error) error //同时附加堆栈和信息 func Wrap(err error, message string) error 有包装方法，就有对应的解包方法，Cause方法会返回包装错误对应的最原始错误--即会递归地进行解包。 func Cause(err error) error 下面是使用github.com/pkg/errors改写后的错误处理程序 func ReadFile(path string) ([]byte, error) { f, err := os.Open(path) if err != nil { return nil, errors.Wrap(err, "open failed") } defer f.Close() buf, err := ioutil.ReadAll(f) if err != nil { return nil, errors.Wrap(err, "read failed") } return buf, nil } func ReadConfig() ([]byte, error) { home := os.Getenv("HOME") config, err := ReadFile(filepath.Join(home, ".settings.xml")) return config, errors.WithMessage(err, "could not read config") } func main() { _, err := ReadConfig() if err != nil { fmt.Printf("original error: %T %v\n", errors.Cause(err), errors.Cause(err)) fmt.Printf("stack trace:\n%+v\n", err) os.Exit(1) } } 上面格式化字符串时用的 %+v 是在 % v 基础上，对值进行展开，即展开复合类型值，比如结构体的字段值等明细。 这样既能给错误添加调用栈信息，又能保留对原始错误的引用，通过Cause可以还原到最初始引发错误的原因。 总结 总结一下，错误处理的原则就是： 错误只在逻辑的最外层处理一次，底层只返回错误。 底层除了返回错误外，要对原始错误进行包装，增加错误信息、调用栈等这些有利于排查的上下文信息。 到此这篇关于Go程序错误处理的相关建议的文章就介绍到这了,更多相关Go程序错误处理内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

使用 Go 语言开发微服务的时候，需要追踪每一个请求的访问链路，这块在 Go 中目前没有很好的解决方案。 在 Java 中解决这个问题比较简单，可以使用 MDC，在一个进程内共享一个请求的 RequestId。 在 Go 中实现链路追踪有两种思路：一种是在项目中使用一个全局的 map， key 是 goroutine 的唯一 Id，value 是 RequestId，另一种思路可以使用 context.Context 来实现。 下面的代码基于 gin 框架来实现。 1. 使用全局 map 来实现 使用 map 方案需要在全局维护一个 map，在一个请求进来的时候，会为每一个请求生成 RequestId，然后在每次在打印日志的时候，从这个 Map 中通过 goid 获取到 RequestId，打印到日志中。 代码的实现很简单： var requestIdMap = make(map[int64]string) // 全局的 Map func main() { r := gin.Default() r.Use(Logger()) // 使用中间件 r.GET("/index", func(c *gin.Context) { Info("main goroutine") // 打印日志 c.JSON(200, gin.H{ "message": "index", }) }) r.Run() } func Logger() gin.HandlerFunc { return func(c *gin.Context) { requestIdMap[goid.Get()] = uuid.New().String() // 在日志中间件中为每个请求设定 c.Next() } } func Info(msg string) { now := time.Now() nowStr := now.Format("2006-01-02 15:04:05") fmt.Printf("%s [%s] %s\n", nowStr, requestIdMap[goid.Get()], msg) // 打印日志 } 这样的实现很简单，但是问题也很多。 第一个问题就是，在 Go 程序中，一次请求可能会涉及到多个 goroutine，用这种方式很难在多个 gotoutine 之间传递 RequestId。 在下面的代码中，如果新启动了一个 goroutine，就会导致日志中获取不到 RequestId： func main() { r := gin.Default() r.Use(Logger()) r.GET("/index", func(c *gin.Context) { Info("main goroutine") go func() { // 这里新启动了一个一个 goroutine Info("goroutine1") }() c.JSON(200, gin.H{ "message": "index", }) }) r.Run() } 获取 goroutine id 也不是一种常规的做法，一般要通过 hack 的方式来获取，这种做法已经不推荐了。而且这个全局的 map 为了并发安全，在实际的使用中，可以还需要用到锁，在高并发的情况下必然会影响性能。 在每个请求结束的时候，还需要手动的把 requestId 从 map 中删除，否则就会造成内存泄漏。 总的来说，使用 map 这种方式来实现并不是很好。 2. 使用 Context 来实现 在上面的代码中，我们使用一个 hack 的方式去获取 goroutine id，这种方式早就不推荐使用，更推荐使用 Context，关于 Context 内容，可以去看我之前的文章，在这里就不多说了。 在传递 RequestId 的场景中，同样也可以使用 Context 来实现，使用 Context 好处很明显，Context 生命周期与请求相同，不需要手动销毁。而且Context 是每个请求独享的，也不用担心并发安全的问题，Context 还可以在 goroutine 之间传递。 使用 Context 实现的代码如下： func main() { r := gin.Default() r.Use(Logger()) r.GET("/index", func(c *gin.Context) { ctx, _ := c.Get("ctx") Info(ctx.(context.Context) , "main goroutine") go func() { Info(ctx.(context.Context), "goroutine1") }() c.JSON(200, gin.H{ "message": "index", }) }) r.Run() } func Logger() gin.HandlerFunc { return func(c *gin.Context) { valueCtx := context.WithValue(c.Request.Context(), "RequestId", uuid.New().String()) c.Set("ctx", valueCtx) c.Next() } } func Info(ctx context.Context, msg string) { now := time.Now() nowStr := now.Format("2006-01-02 15:04:05") fmt.Printf("%s [%s] %s\n", nowStr, ctx.Value("RequestId"), msg) } 这样在一个请求中，所有的 gotroutine 都可以获取到同一个 RequestId，而且不用担心内存泄漏和并发安全。 但是使用 Context 也有个问题就是需要每次传递 Context，很多人还不习惯使用这种方式。其实 Go 官方早就推荐使用 Context了，通常会把 Context 作为函数的第一个参数。如果函数使用结构体作为参数，也可以直接把 Context 作为结构体的一个字段。 Context 除了使用可以同来传递 RequestId 之外，还可以用来控制 goroutine 的生命周期，这些内容在之前的 Context 文章中详细说明了，感兴趣的可以去看看。 3. 小结 获取 goroutine id 这种方式应该被抛弃，而是应该使用 Context, Go 官方也早就推荐使用这种方式，在上文中，我们使用 Context 来传递 RequestId，除此之外还可以用来传递单个请求范围的值，比如认证的 token 之类的，应该习惯在代码中使用 Context。 [1] https://blog.golang.org/context 到此这篇关于详解如何在Go 服务中做链路追踪的文章就介绍到这了,更多相关Go 服务中做链路追踪内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

在早期经常遭到唾弃的就是在垃圾回收(下称：GC)机制中 STW(Stop-The-World)的时间过长。那么这个时候，我们又会好奇一点，作为 STW 的起始，Go 语言中什么时候才会触发 GC 呢? 1、什么是 GC 在计算机科学中，垃圾回收(GC)是一种自动管理内存的机制，垃圾回收器会去尝试回收程序不再使用的对象及其占用的内存。 最早 John McCarthy 在 1959 年左右发明了垃圾回收，以简化 Lisp 中的手动内存管理的机制(来自 @wikipedia)。 2、为什么要 GC 手动管理内存挺麻烦，管错或者管漏内存也很糟糕，将会直接导致程序不稳定(持续泄露)甚至直接崩溃。 3、GC 触发场景 GC 触发的场景主要分为两大类，分别是： 系统触发：运行时自行根据内置的条件，检查、发现到，则进行 GC 处理，维护整个应用程序的可用性。 手动触发：开发者在业务代码中自行调用 runtime.GC 方法来触发 GC 行为。 3.1系统触发 在系统触发的场景中，Go 源码的 src/runtime/mgc.go 文件，明确标识了 GC 系统触发的三种场景，分别如下： const ( gcTriggerHeap gcTriggerKind = iota gcTriggerTime gcTriggerCycle ) gcTriggerHeap：当所分配的堆大小达到阈值(由控制器计算的触发堆的大小)时，将会触发。 gcTriggerTime：当距离上一个 GC 周期的时间超过一定时间时，将会触发。-时间周期以 runtime.forcegcperiod 变量为准，默认 2 分钟。 gcTriggerCycle：如果没有开启 GC，则启动 GC。 在手动触发的 runtime.GC 方法中涉及。 3.2手动触发 在手动触发的场景下，Go 语言中仅有 runtime.GC 方法可以触发，也就没什么额外的分类的。 但我们要思考的是，一般我们在什么业务场景中，要涉及到手动干涉 GC，强制触发他呢? 需要手动强制触发的场景极其少见，可能会是在某些业务方法执行完后，因其占用了过多的内存，需要人为释放。又或是 debug 程序所需。 3.3 基本流程 在了解到 Go 语言会触发 GC 的场景后，我们进一步看看触发 GC 的流程代码是怎么样的，我们可以借助手动触发的 runtime.GC 方法来作为突破口。 核心代码如下： func GC() { n := atomic.Load(&work.cycles) gcWaitOnMark(n) gcStart(gcTrigger{kind: gcTriggerCycle, n: n + 1}) gcWaitOnMark(n + 1) for atomic.Load(&work.cycles) == n+1 && sweepone() != ^uintptr(0) { sweep.nbgsweep++ Gosched() } for atomic.Load(&work.cycles) == n+1 && atomic.Load(&mheap_.sweepers) != 0 { Gosched() } mp := acquirem() cycle := atomic.Load(&work.cycles) if cycle == n+1 || (gcphase == _GCmark && cycle == n+2) { mProf_PostSweep() } releasem(mp) } 在开始新的一轮 GC 周期前，需要调用 gcWaitOnMark 方法上一轮 GC 的标记结束(含扫描终止、标记、或标记终止等)。 开始新的一轮 GC 周期，调用 gcStart 方法触发 GC 行为，开始扫描标记阶段。 需要调用 gcWaitOnMark 方法等待，直到当前 GC 周期的扫描、标记、标记终止完成。 需要调用 sweepone 方法，扫描未扫除的堆跨度，并持续扫除，保证清理完成。在等待扫除完毕前的阻塞时间，会调用 Gosched 让出。 在本轮 GC 已经基本完成后，会调用 mProf_PostSweep 方法。以此记录最后一次标记终止时的堆配置文件快照。 结束，释放 M。 3.4 在哪触发 看完 GC 的基本流程后，我们有了一个基本的了解。但可能又有小伙伴有疑惑了? 本文的标题是 “GC 什么时候会触发 GC”，虽然我们前面知道了触发的时机。但是....Go 是哪里实现的触发的机制，似乎在流程中完全没有看到? 4、监控线程 实质上在 Go 运行时(runtime)初始化时，会启动一个 goroutine，用于处理 GC 机制的相关事项。 代码如下： func init() { go forcegchelper() } func forcegchelper() { forcegc.g = getg() lockInit(&forcegc.lock, lockRankForcegc) for { lock(&forcegc.lock) if forcegc.idle != 0 { throw("forcegc: phase error") } atomic.Store(&forcegc.idle, 1) goparkunlock(&forcegc.lock, waitReasonForceGCIdle, traceEvGoBlock, 1) // this goroutine is explicitly resumed by sysmon if debug.gctrace > 0 { println("GC forced") } gcStart(gcTrigger{kind: gcTriggerTime, now: nanotime()}) } } 在这段程序中，需要特别关注的是在 forcegchelper 方法中，会调用 goparkunlock 方法让该 goroutine 陷入休眠等待状态，以减少不必要的资源开销。 在休眠后，会由 sysmon 这一个系统监控线程来进行监控、唤醒等行为： func sysmon() { ... for { ... // check if we need to force a GC if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && atomic.Load(&forcegc.idle) != 0 { lock(&forcegc.lock) forcegc.idle = 0 var list gList list.push(forcegc.g) injectglist(&list) unlock(&forcegc.lock) } if debug.schedtrace > 0 && lasttrace+int64(debug.schedtrace)*1000000 <= now { lasttrace = now schedtrace(debug.scheddetail > 0) } unlock(&sched.sysmonlock) } } 这段代码核心的行为就是不断地在 for 循环中，对 gcTriggerTime 和 now 变量进行比较，判断是否达到一定的时间(默认为 2 分钟)。 若达到意味着满足条件，会将 forcegc.g 放到全局队列中接受新的一轮调度，再进行对上面 forcegchelper 的唤醒。 5、堆内存申请 在了解定时触发的机制后，另外一个场景就是分配的堆空间的时候，那么我们要看的地方就非常明确了。 那就是运行时申请堆内存的 mallocgc 方法。核心代码如下： func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer { shouldhelpgc := false ... if size <= maxSmallSize { if noscan && size < maxTinySize { ... // Allocate a new maxTinySize block. span = c.alloc[tinySpanClass] v := nextFreeFast(span) if v == 0 { v, span, shouldhelpgc = c.nextFree(tinySpanClass) } ... spc := makeSpanClass(sizeclass, noscan) span = c.alloc[spc] v := nextFreeFast(span) if v == 0 { v, span, shouldhelpgc = c.nextFree(spc) } ... } } else { shouldhelpgc = true span = c.allocLarge(size, needzero, noscan) ... } if shouldhelpgc { if t := (gcTrigger{kind: gcTriggerHeap}); t.test() { gcStart(t) } } return x } 小对象：如果申请小对象时，发现当前内存空间不存在空闲跨度时，将会需要调用 nextFree 方法获取新的可用的对象，可能会触发 GC 行为。 大对象：如果申请大于 32k 以上的大对象时，可能会触发 GC 行为。 总结 在这篇文章中，我们介绍了 Go 语言触发 GC 的两大类场景，并分别基于大类中的细分场景进行了一一说明。 到此这篇关于谈论Go 什么时候会触发 GC问题的文章就介绍到这了,更多相关Go 什么时候会触发 GC？内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、基础介绍 Go 是静态（编译型）语言，是区别于解释型语言的弱类型语言（静态：类型固定，强类型：不同类型不允许直接运算） 例如 python 就是动态强类型语言 1、Go 的特性 跨平台的编译型语言，交叉编译 管道（channel），切片（slice），并发（routine） 有垃圾回收机制 支持面向对象和面向过程的编程模式（Go 的面向对象没有类的概念） 2、Go 的常用命令 go env // go的环境变量 -GO111MODULE= // 空的，现在没有使用MODULE模式 -GOPATH=C:\Users\oldboy\go // 代码存放路径 -GOROOT=c:\go // go sdk安装路径 go build // 编译型语言，需要先编译再执行，编译成可执行文件，执行可执行文件 go run // 编译并执行，开发阶段用，两步并作一步 go get // 下载并安装包和依赖等同于pip install go version go fmt // 运行gofmt进行格式化（go fmt ：自动将代码格式） 3、Hello Word // 单行注释 /* 多行注释 多行注释 */ // Go（所有编译型语言）项目要运行，必须有一个入口 // Go 的入口是 main 包下的 main 函数 // main 包下可不可以有多个 main 函数 package main // 声明包名，包名是 main，每一个 Go 文件都属于某个包 import "fmt" // 导入包，内置包 func main() { // 定义了一个main函数，大括号包裹是函数体的内容 fmt.Println("Hello World") // 打印函数等同与print() } // 编译 go build s1.go // 执行 s1.exe // 编译并执行 go run s1.go // 在goland中，右键，运行即可 二、变量 go 语言的变量定义方式主要分为三种方式，并且不能重复定义。 1、定义方式 方式一：全定义 // var 变量名 变量类型 = 变量值 package main import "fmt" func main() { var age int = 10 // 在go中，变量定义了就必须使用，如果不使用就报错 fmt.Println(age) } 方式二：类型推导（类型就不需要写了） package main import "fmt" func main() { var age = 20 var name = "XiaoYang" fmt.Println(age, name) fmt.Printf("%T\n",name) // 查看变量类型 \n表示换行 fmt.Printf("%p",&name) // 查看变量内存地址 } // 输出 20 XiaoYang string 0xc000056230 方式三：简略声明（类型和 var 关键字都不写） package main import "fmt" func main() { age := 20 var age int = 30 // 重复定义会报错，不能重复定义 fmt.Println(age) } 其他定义方式：其他定义方式都是在前三种方式的基础上做出变形而出现的： 只定义不赋值： var age int // 定义变量，如果只定义不赋值，只能用这种方式 var age // 错误，无法判断类型 声明多个变量： var width, height int = 100, 50 // 声明多个变量 var width, height = 100, 50 // 声明多个变量 var width, height = 100, "XiaoYang" // 声明多个变量 width, height := 100, "XiaoYang" // 声明多个变量 声明多个变量，并赋初始值： var ( name = "XiaoYang" age int = 20 height int ) fmt.Println(name, age, height) 注意： var age int = 20 name, age := "XiaoYang", 21 // 这种情况不会报错，我们觉得是重复定义，冒号左侧只要有一个没有定义过得变量就可以。 fmt.Println(name, age) 总结： 变量类型在定义阶段就确定了，一旦确定，不允许改变 变量不可以重复定义 变量要先定义在使用 变量定义规范 变量命名建尽量使用驼峰（大小写有特殊意义） Go 文件命名建议用下划线 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意的字母、数字或下划线 大写字母和小写字母是不同的：Name 和 name 是两个不同的变量 关键字和保留字都不建议用作变量名 三、常量 常量定义的定义使用 const 关键字定义，不允许改变 方式一： package main import "fmt" func main() { const age int = 20 // 不允许修改，修改会报错 fmt.Println(age) } 方式二：类型推导 package main import "fmt" func main() { const age = 20 fmt.Println(age) } 注意：不能使用 := 这种方式定义，这样就是定义变量了 四、基础数据类型 1、数字 // 有符号整形 int： 在32位机器是int32，在64位机器是int64 int8： 表示整数范围是：8个比特位，8个bit是1byte ，第一位表示正负数0/1， 所以是2的7次方-1 的范围 int16： 2的15次方减一 int32： 2的32次方减一 int64： 2的64次方减一 byte： 等于int8 short： 等于int16 // 无符号整形 uint8： 没有负数表示，所以是2的8次方减一 uint16： 同上 uint32： uint64： 2、浮点型（小数，32/64表示小数点后长度多少位） float32 float64 3、布尔（Bool） // 数据类型默认值： 数字类型是 0 字符串类型是 空字符串 布尔类型 false 4、字符串 // 双引号包裹 // 单引号包裹 到此这篇关于Go变量与基础数据类型详情的文章就介绍到这了,更多相关Go变量与基础数据类型内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1、逃逸分析介绍 学计算机的同学都知道，在编译原理中，分析指针动态范围的方法称之为逃逸分析。通俗来讲，当一个对象的指针被多个方法或线程引用时，我们称这个指针发生了“逃逸”。 Go语言的逃逸分析是编译器执行静态代码分析后，对内存管理进行的优化和简化，它可以决定一个变量是分配到堆还栈上。 写过C/C++的小伙伴应该知道，使用比较经典的malloc和new函数可以在堆上分配一块内存，这块内存的使用和回收（销毁）的任务在程序员中，处理不当，很可能会发生内存泄露。 2、Go中内存分配在哪里？ 但是在Go语言中，基本不用担心内存泄露的问题，因为内存回收Go语言中已经帮我们处理了（GC回收机制）。虽然也有new函数，但是使用new函数得到的内存不一定就在堆上。堆和栈的区别对程序员“模糊化”了，当然这一切都是Go编译器在背后帮我们完成的。 Go语言逃逸分析最基本的原则是：如果一个函数返回对一个变量的引用，那么它就会发生逃逸。 简单来说，编译器会分析代码的特征和代码生命周期，Go中的变量只有在编译器可以证明在函数返回后不会再被引用的，才分配到栈上，其他情况下都是分配到堆上。 Go语言里没有一个关键字或者函数可以直接让变量被编译器分配到堆上，相反，编译器通过分析代码来决定将变量分配到何处。 对一个变量取地址，可能会被分配到堆上。但是编译器进行逃逸分析后，如果考察到在函数返回后，此变量不会被引用，那么还是会被分配到栈上。 编译器会根据变量是否被外部引用来决定是否逃逸： 如果在函数外面没有引用到，则优先放到栈区中； 如果在函数外面存在引用的可能，则就会放到堆区中； 当我们写C/C++代码时，为了提高效率，会经常将pass-by-value（传值）提升成pass-by-reference，企图避免构造函数的运行，并且直接返回一个指针。 你一定还记得，这里隐藏了一个很大的坑：在函数内部定义了一个局部变量，然后返回这个局部变量的地址（指针）。这些局部变量是在栈上分配的（静态内存分配），一旦函数执行完毕，变量占据的内存会被销毁，任何对这个返回值作的动作（如解引用），都将扰乱程序的运行，甚至导致程序直接崩溃。比如下面的这段代码： int *foo ( void ) { int t = 3; return &t; } 有些同学可能知道上面这个坑，用了个更聪明的做法：在函数内部使用new函数构造一个变量（动态内存分配），然后返回此变量的地址。因为变量是在堆上创建的，所以函数退出时不会被销毁。 但是，这样就行了吗？new出来的对象该在何时何地delete呢？调用者可能会忘记delete或者直接拿返回值传给其他函数，之后就再也不能delete它了，也就是发生了内存泄露。关于这个坑，大家可以去看看《Effective C++》条款21，讲得非常好！ 3、Go与C++内存分配的区别 上面讲的C/C++中会遇到的问题，在Go中作为一个语言特性被大力推崇，可以解决以上的难点！ C/C++中的动态分配的内存需要我们手动来释放，这样会带来一个问题：有些内存处理不当或回收不及时，导致内存泄露。 但是这样的好处是：开发人员可以自己管理内存。 Go的垃圾回收，让堆和栈对程序员保持透明。真正解放了程序员的双手，让他们可以专注于业务，“高效”地完成代码编写。把那些内存管理的复杂机制交给编译器，而程序员可以去享受生活。 4、逃逸分析骚操作 逃逸分析这种“骚操作”把变量合理地分配到它该去的地方。即使你是用new申请到的内存，如果我发现你竟然在退出函数后没有用了，那么就把你丢到栈上，毕竟栈上的内存分配比堆上快很多；反之，即使你表面上只是一个普通的变量，但是经过逃逸分析后发现在退出函数之后还有其他地方在引用，那我就把你分配到堆上。 如果变量都分配到堆上，堆不像栈可以自动清理。它会引起Go频繁地进行垃圾回收，而垃圾回收会占用比较大的系统开销（占用CPU容量的25%）。 堆和栈相比，堆适合不可预知大小的内存分配。但是为此付出的代价是分配速度较慢，而且会形成内存碎片。栈内存分配则会非常快。栈分配内存只需要两个CPU指令：“PUSH”和“RELEASE”，分配和释放；而堆分配内存首先需要去找到一块大小合适的内存块，之后要通过垃圾回收才能释放。 通过逃逸分析，可以尽量把那些不需要分配到堆上的变量直接分配到栈上，堆上的变量少了，会减轻分配堆内存的开销，同时也会减少gc的压力，提高程序的运行速度。 5、逃逸分析引申示例说明 引申1：如何查看某个变量是否发生了逃逸？两种方法：使用go命令，查看逃逸分析结果；反汇编源码； 比如用这个例子： package main import "fmt" func foo() *int { t := 3 return &t; } func main() { x := foo() fmt.Println(*x) } 使用go命令： go build -gcflags '-m -l' main.go 加-l是为了不让foo函数被内联。得到如下输出： # 命令行变量 src/main.go:7:9: &t escapes to heap src/main.go:6:7: moved to heap: t src/main.go:12:14: *x escapes to heap src/main.go:12:13: main ... argument does not escape foo函数里的变量t逃逸了，和我们预想的一致。让我们不解的是为什么main函数里的x也逃逸了？这是因为有些函数参数为interface类型，比如fmt.Println(a …interface{}) ，编译期间很难确定其参数的具体类型，也会发生逃逸。 反汇编代码比较难理解，这里就不讲了。 引申2：下面代码中的变量发生逃逸了吗？ 先来看示例1： package main type S struct {} func main() { var x S _ = identity(x) } func identity(x S) S { return x } 分析：Go语言函数传递都是通过值的，调用函数的时候，直接在栈上copy出一份参数，不存在逃逸。  再来看示例二： package main type S struct {} func main() { var x S y := &x _ = *identity(y) } func identity(z *S) *S { return z } 分析：identity函数的输入直接当成返回值了，因为没有对z作引用，所以z没有逃逸。对x的引用也没有逃出main函数的作用域，因此x也没有发生逃逸。  继续看示例三： package main type S struct {} func main() { var x S _ = *ref(x) } func ref(z S) *S { return &z } 分析：z是对x的拷贝，ref函数中对z取了引用，所以z不能放在栈上，否则在ref函数之外，通过引用如何找到z，所以z必须要逃逸到堆上。仅管在main函数中，直接丢弃了ref的结果，但是Go的编译器还没有那么智能，分析不出来这种情况。而对x从来就没有取引用，所以x不会发生逃逸。 还有示例四：如果对一个结构体成员赋引用如何？ package main type S struct { M *int } func main() { var i int refStruct(i) } func refStruct(y int) (z S) { z.M = &y return z } 分析：refStruct函数对y取了引用，所以y发生了逃逸。  最后看示例五： package main type S struct { M *int } func main() { var i int refStruct(&i) } func refStruct(y *int) (z S) { z.M = y return z } 分析：在main函数里对i取了引用，并且把它传给了refStruct函数，i的引用一直在main函数的作用域用，因此i没有发生逃逸。和上一个例子相比，有一点小差别，但是导致的程序效果是不同的：例子4中，i先在main的栈帧中分配，之后又在refStruct栈帧中分配，然后又逃逸到堆上，到堆上分配了一次，共3次分配。本例中，i只分配了一次，然后通过引用传递。 到此这篇关于Go语言中的逃逸分析究竟是什么?的文章就介绍到这了,更多相关Go语言中的逃逸内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文