异常处理 程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常 golang中提供了两种处理异常的方式 一种是程序发生异常时, 将异常信息反馈给使用者 一种是程序发生异常时, 立刻退出终止程序继续运行 打印异常信息 Go语言中提供了两种创建异常信息的方式 方式一: 通过fmt包中的Errorf函数创建错误信息, 然后打印 package main import "fmt" func main() { // 1.创建错误信息 var err error = fmt.Errorf("这里是错误信息") // 2.打印错误信息 fmt.Println(err) // 这里是错误信息 } 方式二: 通过errors包中的New函数创建错误信息,然后打印 package main import "fmt" func main() { // 1.创建错误信息 var err error = errors.New("这里是错误信息") // 2.打印错误信息 fmt.Println(err) // 这里是错误信息 } 两种创建异常信息实现原理解析 Go语言中创建异常信息其实都是通过一个error接口实现的 Go语言再builtin包中定义了一个名称叫做error的接口. 源码如下 package builtin // 定义了一个名称叫做error的接口 // 接口中声明了一个叫做Error() 的方法 type error interface { Error() string } 在errors包中定义了一个名称叫做做errorString的结构体, 利用这个结构体实现了error接口中指定的方法 并且在errors 包中还提供了一个New方法, 用于创建实现了error接口的结构体对象, 并且在创建时就会把指定的字符串传递给这个结构体 // 指定包名为errors package errors // 定义了一个名称叫做errorString的结构体, 里面有一个字符串类型属性s type errorString struct { s string } // 实现了error接口中的Error方法 // 内部直接将结构体中保存的字符串返回 func (e *errorString) Error() string { return e.s } // 定义了一个New函数, 用于创建异常信息 // 注意: New函数的返回值是一个接口类型 func New(text string) error { // 返回一个创建好的errorString结构体地址 return &errorString{text} } fmt包中Errorf底层的实现原理其实就是在内部自动调用了errors包中的New函数 func Errorf(format string, a ...interface{}) error { return errors.New(Sprintf(format, a...)) } 应用场景 package main import "fmt" func div(a, b int) (res int, err error) { if(b == 0){ // 一旦传入的除数为0, 就会返回error信息 err = errors.New("除数不能为0") }else{ res = a / b } return } func main() { //res, err := div(10, 5) res, err := div(10, 0) if(err != nil){ fmt.Println(err) // 除数不能为0 }else{ fmt.Println(res) // 2 } } 中断程序 Go语言中提供了一个叫做panic函数, 用于发生异常时终止程序继续运行 package main import "fmt" func div(a, b int) (res int) { if(b == 0){ //一旦传入的除数为0, 程序就会终止 panic("除数不能为0") }else{ res = a / b } return } func main() { res := div(10, 0) fmt.Println(res) } Go语言中有两种方式可以触发panic终止程序 我们自己手动调用panic函数 程序内部出现问题自动触发panic函数 package main import "fmt" func main() { // 例如:数组角标越界, 就会自动触发panic var arr = [3]int{1, 3, 5} arr[5] = 666 // 报错 fmt.Println(arr) // 例如:除数为0, 就会自动触发panic var res = 10 / 0 fmt.Println(res) } 除非是不可恢复性、导致系统无法正常工作的错误, 否则不建议使用panic 恢复程序 程序和人一样都需要具备一定的容错能力, 学会知错就改. 所以如果不是不可恢复性、导致系统无法正常工作的错误, 如果发生了panic我们需要恢复程序, 让程序继续执行,并且需要记录到底犯了什么错误 在Go语言中我们可以通过defer和recover来实现panic异常的捕获, 让程序继续执行 package main import "fmt" func div(a, b int) (res int) { // 定义一个延迟调用的函数, 用于捕获panic异常 // 注意: 一定要在panic之前定义 defer func() { if err := recover(); err != nil{ res = -1 fmt.Println(err) // 除数不能为0 } }() if(b == 0){ //err = errors.New("除数不能为0") panic("除数不能为0") }else{ res = a / b } return } func setValue(arr []int, index int ,value int) { arr[index] = value } func main() { res := div(10, 0) fmt.Println(res) // -1 } panic注意点 panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获 package main import "fmt" func div(a, b int) (res int) { if(b == 0){ //err = errors.New("除数不能为0") panic("除数不能为0") }else{ res = a / b } return } func main() { // panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获 defer func() { if err := recover(); err != nil{ fmt.Println(err) // 除数不能为0 } }() div(10, 0) } 多个异常,只有第一个会被捕获 package main import "fmt" func test1() { // 多个异常,只有第一个会被捕获 defer func() { if err := recover(); err != nil{ fmt.Println(err) // 异常A } }() panic("异常A") // 相当于return, 后面代码不会继续执行 panic("异常B") } func main() { test1(10, 0) } 如果有异常写在defer中, 那么只有defer中的异常会被捕获 package main import "fmt" func test2() { // 如果有异常写在defer中, 并且其它异常写在defer后面, 那么只有defer中的异常会被捕获 defer func() { if err := recover(); err != nil{ fmt.Println(err) // 异常A } }() defer func() { panic("异常B") }() panic("异常A") } func main() { test1(10, 0) } 到此这篇关 异常处理 程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常 golang中提供了两种处理异常的方式 一种是程序发生异常时, 将异常信息反馈给使用者 一种是程序发生异常时, 立刻退出终止程序继续运行 打印异常信息 Go语言中提供了两种创建异常信息的方式 方式一: 通过fmt包中的Errorf函数创建错误信息, 然后打印 package main import "fmt" func main() { // 1.创建错误信息 var err error = fmt.Errorf("这里是错误信息") // 2.打印错误信息 fmt.Println(err) // 这里是错误信息 } 方式二: 通过errors包中的New函数创建错误信息,然后打印 package main import "fmt" func main() { // 1.创建错误信息 var err error = errors.New("这里是错误信息") // 2.打印错误信息 fmt.Println(err) // 这里是错误信息 } 两种创建异常信息实现原理解析 Go语言中创建异常信息其实都是通过一个error接口实现的 Go语言再builtin包中定义了一个名称叫做error的接口. 源码如下 package builtin // 定义了一个名称叫做error的接口 // 接口中声明了一个叫做Error() 的方法 type error interface { Error() string } 在errors包中定义了一个名称叫做做errorString的结构体, 利用这个结构体实现了error接口中指定的方法 并且在errors 包中还提供了一个New方法, 用于创建实现了error接口的结构体对象, 并且在创建时就会把指定的字符串传递给这个结构体 // 指定包名为errors package errors // 定义了一个名称叫做errorString的结构体, 里面有一个字符串类型属性s type errorString struct { s string } // 实现了error接口中的Error方法 // 内部直接将结构体中保存的字符串返回 func (e *errorString) Error() string { return e.s } // 定义了一个New函数, 用于创建异常信息 // 注意: New函数的返回值是一个接口类型 func New(text string) error { // 返回一个创建好的errorString结构体地址 return &errorString{text} } fmt包中Errorf底层的实现原理其实就是在内部自动调用了errors包中的New函数 func Errorf(format string, a ...interface{}) error { return errors.New(Sprintf(format, a...)) } 应用场景 package main import "fmt" func div(a, b int) (res int, err error) { if(b == 0){ // 一旦传入的除数为0, 就会返回error信息 err = errors.New("除数不能为0") }else{ res = a / b } return } func main() { //res, err := div(10, 5) res, err := div(10, 0) if(err != nil){ fmt.Println(err) // 除数不能为0 }else{ fmt.Println(res) // 2 } } 中断程序 Go语言中提供了一个叫做panic函数, 用于发生异常时终止程序继续运行 package main import "fmt" func div(a, b int) (res int) { if(b == 0){ //一旦传入的除数为0, 程序就会终止 panic("除数不能为0") }else{ res = a / b } return } func main() { res := div(10, 0) fmt.Println(res) } Go语言中有两种方式可以触发panic终止程序 我们自己手动调用panic函数 程序内部出现问题自动触发panic函数 package main import "fmt" func main() { // 例如:数组角标越界, 就会自动触发panic var arr = [3]int{1, 3, 5} arr[5] = 666 // 报错 fmt.Println(arr) // 例如:除数为0, 就会自动触发panic var res = 10 / 0 fmt.Println(res) } 除非是不可恢复性、导致系统无法正常工作的错误, 否则不建议使用panic 恢复程序 程序和人一样都需要具备一定的容错能力, 学会知错就改. 所以如果不是不可恢复性、导致系统无法正常工作的错误, 如果发生了panic我们需要恢复程序, 让程序继续执行,并且需要记录到底犯了什么错误 在Go语言中我们可以通过defer和recover来实现panic异常的捕获, 让程序继续执行 package main import "fmt" func div(a, b int) (res int) { // 定义一个延迟调用的函数, 用于捕获panic异常 // 注意: 一定要在panic之前定义 defer func() { if err := recover(); err != nil{ res = -1 fmt.Println(err) // 除数不能为0 } }() if(b == 0){ //err = errors.New("除数不能为0") panic("除数不能为0") }else{ res = a / b } return } func setValue(arr []int, index int ,value int) { arr[index] = value } func main() { res := div(10, 0) fmt.Println(res) // -1 } panic注意点 panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获 package main import "fmt" func div(a, b int) (res int) { if(b == 0){ //err = errors.New("除数不能为0") panic("除数不能为0") }else{ res = a / b } return } func main() { // panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获 defer func() { if err := recover(); err != nil{ fmt.Println(err) // 除数不能为0 } }() div(10, 0) } 多个异常,只有第一个会被捕获 package main import "fmt" func test1() { // 多个异常,只有第一个会被捕获 defer func() { if err := recover(); err != nil{ fmt.Println(err) // 异常A } }() panic("异常A") // 相当于return, 后面代码不会继续执行 panic("异常B") } func main() { test1(10, 0) } 如果有异常写在defer中, 那么只有defer中的异常会被捕获 package main import "fmt" func test2() { // 如果有异常写在defer中, 并且其它异常写在defer后面, 那么只有defer中的异常会被捕获 defer func() { if err := recover(); err != nil{ fmt.Println(err) // 异常A } }() defer func() { panic("异常B") }() panic("异常A") } func main() { test1(10, 0) } 到此这篇关Go语言 ......查看全文

查看官方文档，官方自带的演示： // 官方演示 package main import ( "archive/tar" "bytes" "fmt" "io" "log" "os" ) func main() { // 将若干文件写入压缩文档 // 这边源文件是直接写在代码里哈，然后也没有输出一个文档 // 后面会演示源文件进行压缩，然后输出一个tar.gz的压缩文档 var buf bytes.Buffer tw := tar.NewWriter(&buf) var files = []struct { Name, Body string }{ {"readme.txt", "This archive contains some text files."}, {"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"}, {"todo.txt", "Get animal handling license."}, } for _, file := range files { hdr := &tar.Header{ Name: file.Name, Mode: 0600, Size: int64(len(file.Body)), } if err := tw.WriteHeader(hdr); err != nil { log.Fatal(err) } if _, err := tw.Write([]byte(file.Body)); err != nil { log.Fatal(err) } } if err := tw.Close(); err != nil { log.Fatal(err) } // 上面压缩了之后，压缩内容都存储在buf这个变量里 // 这边遍历输出一下即可 tr := tar.NewReader(&buf) for { hdr, err := tr.Next() if err == io.EOF { break // 文件已经遍历完成了 } if err != nil { log.Fatal(err) } fmt.Printf("%s的文件内容: ", hdr.Name) if _, err := io.Copy(os.Stdout, tr); err != nil { log.Fatal(err) } fmt.Println() } } 1、压缩并输出tar.gz文档 官方的演示中并未将压缩的内容输出文档，实际使用中经常会用到。这边可用os库中的文件操作，将压缩内容写入文档，参考 代码如下： // tar压缩 // 这边演示一下从源文件进行压缩，然后输出一个tar.gz文档 // 作者：陈杰斌 // 参考地址：http://www.01happy.com/golang-tar/ package main import ( "archive/tar" "bytes" "log" "os" ) func main() { // 创建一个缓冲区用来保存压缩文件内容 var buf bytes.Buffer // 创建一个压缩文档 tw := tar.NewWriter(&buf) // 定义一堆文件 // 将文件写入到压缩文档tw var files = []struct { Name, Body string }{ {"readme.txt", "This archive contains some text files."}, {"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"}, {"todo.txt", "Get animal handling license."}, } for _, file := range files { hdr := &tar.Header{ Name: file.Name, Mode: 0600, Size: int64(len(file.Body)), } if err := tw.WriteHeader(hdr); err != nil { log.Fatal(err) } if _, err := tw.Write([]byte(file.Body)); err != nil { log.Fatal(err) } } if err := tw.Close(); err != nil { log.Fatal(err) } // 将压缩文档内容写入文件 file.tar.gz f, err := os.OpenFile("file.tar.gz", os.O_CREATE|os.O_WRONLY, 0666) if err != nil { log.Fatal(err) } buf.WriteTo(f) } 执行一下哈： > go run compress.go golang中tar压缩： 2、tar解压缩 同上，可以使用os库将文档内容读入 // tar解压缩演示 // 这边演示一下从源文件进行解压，然后输出文件内容 // 作者：陈杰斌 // 参考地址：http://www.01happy.com/golang-tar/ package main import ( "archive/tar" "fmt" "io" "log" "os" ) func main() { // 解压需要使用tar.NewReader方法, 这个方法接收一个io.Reader对象 // 那边怎么从源文件得到io.Reader对象呢？ // 这边通过os.Open打开文件,会得到一个os.File对象， // 因为他实现了io.Reader的Read方法，所有可以直接传递给tar.NewReader file, err := os.Open("file.tar.gz") if err != nil { log.Fatalln(err) } defer file.Close() // tar对象读取文件内容, 遍历输出文件内容 tr := tar.NewReader(file) for { hdr, err := tr.Next() if err == io.EOF { break // End of archive } if err != nil { log.Fatal(err) } fmt.Printf("%s文件内容:\n", hdr.Name) if _, err := io.Copy(os.Stdout, tr); err != nil { log.Fatal(err) } fmt.Println() } } 执行一下： > go run decompress.go golang中tar解压： 到此这篇关于golang中tar压缩和解压 查看官方文档，官方自带的演示： // 官方演示 package main import ( "archive/tar" "bytes" "fmt" "io" "log" "os" ) func main() { // 将若干文件写入压缩文档 // 这边源文件是直接写在代码里哈，然后也没有输出一个文档 // 后面会演示源文件进行压缩，然后输出一个tar.gz的压缩文档 var buf bytes.Buffer tw := tar.NewWriter(&buf) var files = []struct { Name, Body string }{ {"readme.txt", "This archive contains some text files."}, {"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"}, {"todo.txt", "Get animal handling license."}, } for _, file := range files { hdr := &tar.Header{ Name: file.Name, Mode: 0600, Size: int64(len(file.Body)), } if err := tw.WriteHeader(hdr); err != nil { log.Fatal(err) } if _, err := tw.Write([]byte(file.Body)); err != nil { log.Fatal(err) } } if err := tw.Close(); err != nil { log.Fatal(err) } // 上面压缩了之后，压缩内容都存储在buf这个变量里 // 这边遍历输出一下即可 tr := tar.NewReader(&buf) for { hdr, err := tr.Next() if err == io.EOF { break // 文件已经遍历完成了 } if err != nil { log.Fatal(err) } fmt.Printf("%s的文件内容: ", hdr.Name) if _, err := io.Copy(os.Stdout, tr); err != nil { log.Fatal(err) } fmt.Println() } } 1、压缩并输出tar.gz文档 官方的演示中并未将压缩的内容输出文档，实际使用中经常会用到。这边可用os库中的文件操作，将压缩内容写入文档，参考 代码如下： // tar压缩 // 这边演示一下从源文件进行压缩，然后输出一个tar.gz文档 // 作者：陈杰斌 // 参考地址：http://www.01happy.com/golang-tar/ package main import ( "archive/tar" "bytes" "log" "os" ) func main() { // 创建一个缓冲区用来保存压缩文件内容 var buf bytes.Buffer // 创建一个压缩文档 tw := tar.NewWriter(&buf) // 定义一堆文件 // 将文件写入到压缩文档tw var files = []struct { Name, Body string }{ {"readme.txt", "This archive contains some text files."}, {"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"}, {"todo.txt", "Get animal handling license."}, } for _, file := range files { hdr := &tar.Header{ Name: file.Name, Mode: 0600, Size: int64(len(file.Body)), } if err := tw.WriteHeader(hdr); err != nil { log.Fatal(err) } if _, err := tw.Write([]byte(file.Body)); err != nil { log.Fatal(err) } } if err := tw.Close(); err != nil { log.Fatal(err) } // 将压缩文档内容写入文件 file.tar.gz f, err := os.OpenFile("file.tar.gz", os.O_CREATE|os.O_WRONLY, 0666) if err != nil { log.Fatal(err) } buf.WriteTo(f) } 执行一下哈： > go run compress.go golang中tar压缩： 2、tar解压缩 同上，可以使用os库将文档内容读入 // tar解压缩演示 // 这边演示一下从源文件进行解压，然后输出文件内容 // 作者：陈杰斌 // 参考地址：http://www.01happy.com/golang-tar/ package main import ( "archive/tar" "fmt" "io" "log" "os" ) func main() { // 解压需要使用tar.NewReader方法, 这个方法接收一个io.Reader对象 // 那边怎么从源文件得到io.Reader对象呢？ // 这边通过os.Open打开文件,会得到一个os.File对象， // 因为他实现了io.Reader的Read方法，所有可以直接传递给tar.NewReader file, err := os.Open("file.tar.gz") if err != nil { log.Fatalln(err) } defer file.Close() // tar对象读取文件内容, 遍历输出文件内容 tr := tar.NewReader(file) for { hdr, err := tr.Next() if err == io.EOF { break // End of archive } if err != nil { log.Fatal(err) } fmt.Printf("%s文件内容:\n", hdr.Name) if _, err := io.Copy(os.Stdout, tr); err != nil { log.Fatal(err) } fmt.Println() } } 执行一下： > go run decompress.go golang中tar解压： 到此这篇关于golang中tar压缩和解压Go语言 ......查看全文

一、语言结构和注意事项 package main // 声明 main 包，表明当前是一个可执行程序 import "fmt"// 导入内置的fmt包 func main(){ // main函数，是程序执行的入口 fmt.Println("Hello World!") // 在终端打印 Hello World! } 需要注意的是包裹代码的左大括号{ 在Golang中不能单独成为一行，例如下面这样： func main() { // 会报错 fmt.Println("Hello World!") // 在终端打印 Hello World! } 除此之外，Golang每行的代码结尾不需要加;号，这跟python是一样的 二、Golang的执行和打包 示例代码 package main // 声明 main 包，表明当前是一个可执行程序 import "fmt" // 导入内置的fmt包 func main(){ // main函数，是程序执行的入口 fmt.Println("按回车键退出：") fmt.Scanln()// 按回车键退出 } 通过点击goland编辑器右上角【绿色三角按钮】进行执行 通过命令go run go代码文件 打包为可执行文件进行执行：go build go代码文件 三、Golang的变量 1. 定义变量 1）在golang中定义变量的一般形式是使用 var 关键字，例如定义一个名为a的int类型变量： var a int 但如果仅定义不使用该变量的话，执行代码会报错，这跟Python是不同的： .\test.go:7:6: a declared but not used 通过打印到终端的方式使用定义的变量a: package main // 声明 main 包，表明当前是一个可执行程序 import "fmt" func main(){ // main函数，是程序执行的入口 var a int fmt.Println(a) } 输出结果 0 //golang仅定义变量而未赋值的话，则初始值为假，（int为0，bool为false，string为‘'） 2）也可以定义一个有初始值的变量： var a int = 3 3）也可以同时定义多个变量： var a, b int = 3, 4 4）也可以不指定类型： var a, b = 3, 4 5）甚至不带var关键字的简洁定义 ： a, b, c := 3, 4,"c" 6）合并定义： var ( a = 3 b = 4 ) 2. 变量名规则 Golang变量名由字母、数字、下划线组成，其中首个字符不能为数字，例如下面的代码执行就会报错： var 1a bool 报错输出结果 unexpected literal 1, expecting name 到此这篇关于Golang 一、语言结构和注意事项 package main // 声明 main 包，表明当前是一个可执行程序 import "fmt" // 导入内置的fmt包 func main(){ // main函数，是程序执行的入口 fmt.Println("Hello World!") // 在终端打印 Hello World! } 需要注意的是包裹代码的左大括号{ 在Golang中不能单独成为一行，例如下面这样： func main() { // 会报错 fmt.Println("Hello World!") // 在终端打印 Hello World! } 除此之外，Golang每行的代码结尾不需要加;号，这跟python是一样的 二、Golang的执行和打包 示例代码 package main // 声明 main 包，表明当前是一个可执行程序 import "fmt" // 导入内置的fmt包 func main(){ // main函数，是程序执行的入口 fmt.Println("按回车键退出：") fmt.Scanln()// 按回车键退出 } 通过点击goland编辑器右上角【绿色三角按钮】进行执行 通过命令go run go代码文件 打包为可执行文件进行执行：go build go代码文件 三、Golang的变量 1. 定义变量 1）在golang中定义变量的一般形式是使用 var 关键字，例如定义一个名为a的int类型变量： var a int 但如果仅定义不使用该变量的话，执行代码会报错，这跟Python是不同的： .\test.go:7:6: a declared but not used 通过打印到终端的方式使用定义的变量a: package main // 声明 main 包，表明当前是一个可执行程序 import "fmt" func main(){ // main函数，是程序执行的入口 var a int fmt.Println(a) } 输出结果 0 //golang仅定义变量而未赋值的话，则初始值为假，（int为0，bool为false，string为‘'） 2）也可以定义一个有初始值的变量： var a int = 3 3）也可以同时定义多个变量： var a, b int = 3, 4 4）也可以不指定类型： var a, b = 3, 4 5）甚至不带var关键字的简洁定义 ： a, b, c := 3, 4,"c" 6）合并定义： var ( a = 3 b = 4 ) 2. 变量名规则 Golang变量名由字母、数字、下划线组成，其中首个字符不能为数字，例如下面的代码执行就会报错： var 1a bool 报错输出结果 unexpected literal 1, expecting name 到此这篇关于GolangGo语言 ......查看全文

一.序 单从库名大概就能猜出其作用。sync.Once使用起来很简单, 下面是一个简单的使用案例 package mainimport ( "fmt" "sync" ) func main() { var ( once sync.Once wg sync.WaitGroup ) for i := 0; i < 10; i++ { wg.Add(1) // 这里要注意讲i显示的当参数传入内部的匿名函数 go func(i int) { defer wg.Done() // fmt.Println("once", i) once.Do(func() { fmt.Println("once", i) }) }(i) } wg.Wait() fmt.Printf("over") } 输出： go run ./demo.go once 9 测试如果不添加once.Do 这段代码，则会输出如下结果，并且每次执行的输出都不一样。 once 9 once 0 once 3 once 6 once 4 once 1 once 5 once 2 once 7 once 8 从两次输出不同，我们可以得知 sync.Once的作用是：保证传入的函数只执行一次 二. 源码分析 2.1结构体 Once的结构体如下 type Once struct { done uint32 m Mutex } 每一个 sync.Once 结构体中都只包含一个用于标识代码块是否执行过的 done 以及一个互斥锁 sync.Mutex 2.2 接口 sync.Once.Do 是 sync.Once 结构体对外唯一暴露的方法，该方法会接收一个入参为空的函数： 如果传入的函数已经执行过，会直接返回 如果传入的函数没有执行过， 会调用sync.Once.doSlow执行传入的参数 func (o *Once) Do(f func()) { // Note: Here is an incorrect implementation of Do: // // if atomic.CompareAndSwapUint32(&o.done, 0, 1) { // f() // } // // Do guarantees that when it returns, f has finished. // This implementation would not implement that guarantee: // given two simultaneous calls, the winner of the cas would // call f, and the second would return immediately, without // waiting for the first's call to f to complete. // This is why the slow path falls back to a mutex, and why // the atomic.StoreUint32 must be delayed until after f returns. if atomic.LoadUint32(&o.done) == 0 { // Outlined slow-path to allow inlining of the fast-path. o.doSlow(f) } } 代码注释中特别给了一个说明: 很容易犯错的一种实现 if atomic.CompareAndSwapUint32(&o.done, 0, 1) { f() } 如果这么实现最大的问题是，如果并发调用，一个 goroutine 执行，另外一个不会等正在执行的这个成功之后返回，而是直接就返回了，这就不能保证传入的方法一定会先执行一次了 正确的实现方式 if atomic.LoadUint32(&o.done) == 0 { // Outlined slow-path to allow inlining of the fast-path. o.doSlow(f) } 会先判断 done 是否为 0，如果不为 0 说明还没执行过，就进入 doSlow func (o *Once) doSlow(f func()) { o.m.Lock() defer o.m.Unlock() if o.done == 0 { defer atomic.StoreUint32(&o.done, 1) f() } } 在 doSlow 当中使用了互斥锁来保证只会执行一次 具体的逻辑 为当前Goroutine获取互斥锁 执行传入的无入参函数； 运行延迟函数， 将成员变量done更新为1 三. 使用场景案例 3.1 单例模式 原子操作配合互斥锁可以实现非常高效的单件模式。互斥锁的代价比普通整数的原子读写高很多，在性能敏感的地方可以增加一个数字型的标志位，通过原子检测标志位状态降低互斥锁的使用次数来提高性能。 type singleton struct {} var ( instance *singleton initialized uint32 mu sync.Mutex ) func Instance() *singleton { if atomic.LoadUint32(&initialized) == 1 { return instance } mu.Lock() defer mu.Unlock() if instance == nil { defer atomic.StoreUint32(&initialized, 1) instance = &singleton{} } return instance } 而使用sync.Once能更简单实现单例模式 type singleton struct {} var ( instance *singleton once sync.Once ) func Instance() *singleton { once.Do(func() { instance = &singleton{} }) return instance } 3.2 加载配置文件示例 延迟一个开销很大的初始化操作到真正用到它的时候再执行是一个很好的实践。因为预先初始化一个变量（比如在init函数中完成初始化）会增加程序的启动耗时，而且有可能实际执行过程中这个变量没有用上，那么这个初始化操作就不是必须要做的。我们来看一个例子： var icons map[string]image.Image func loadIcons() { icons = map[string]image.Image{ "left": loadIcon("left.png"), "up": loadIcon("up.png"), "right": loadIcon("right.png"), "down": loadIcon("down.png"), } } // Icon 被多个goroutine调用时不是并发安全的 // 因为map类型本就不是类型安全数据结构 func Icon(name string) image.Image { if icons == nil { loadIcons() } return icons[name] } 多个goroutine并发调用Icon函数时不是并发安全的，编译器和CPU可能会在保证每个goroutine都满足串行一致的基础上自由地重排访问内存的顺序。loadIcons函数可能会被重排为以下结果： func loadIcons() {     icons = make(map[string]image.Image)     icons["left"] = loadIcon("left.png")     icons["up"] = loadIcon("up.png")     icons["right"] = loadIcon("right.png")     icons["down"] = loadIcon("down.png") } 在这种情况下就会出现即使判断了icons不是nil也不意味着变量初始化完成了。考虑到这种情况，我们能想到的办法就是添加互斥锁，保证初始化icons的时候不会被其他的goroutine操作，但是这样做又会引发性能问题。 可以使用sync.Once 改造代码 var icons map[string]image.Image var loadIconsOnce sync.Once func loadIcons() { icons = map[string]image.Image{ "left": loadIcon("left.png"), "up": loadIcon("up.png"), "right": loadIcon("right.png"), "down": loadIcon("down.png"), } } // Icon 是并发安全的,并且保证了在代码运行的时候才会加载配置 func Icon(name string) image.Image { loadIconsOnce.Do(loadIcons) return icons[name] } 这样设计就能保证初始化操作的时候是并发安全的并且初始化操作也不会被执行多次。 四.总结 作为用于保证函数执行次数的 sync.Once 结构体，它使用互斥锁和 sync/atomic 包提供的方法实现了某个函数在程序运行期间只能执行一次的语义。在使用该结构体时，我们也需要注意以下的问题： sync.Once.Do 方法中传入的函数只会被执行一次，哪怕函数中发生了 panic； 两次调用 sync.Once.Do 方法传入不同的函数只会执行第一次调传入的函数； 五. 参考 https://lailin.xyz/post/go-training-week3-once.html https://www.topgoer.cn/docs/gozhuanjia/chapter055.2-waitgroup https://www.topgoer.com/并发编程/sync.html https://chai2010.cn/advanced-go-programming-book/ch1-basic/ch1-05-mem.html 到此这篇关于Go 一.序 单从库名大概就能猜出其作用。sync.Once使用起来很简单, 下面是一个简单的使用案例 package main import ( "fmt" "sync" ) func main() { var ( once sync.Once wg sync.WaitGroup ) for i := 0; i < 10; i++ { wg.Add(1) // 这里要注意讲i显示的当参数传入内部的匿名函数 go func(i int) { defer wg.Done() // fmt.Println("once", i) once.Do(func() { fmt.Println("once", i) }) }(i) } wg.Wait() fmt.Printf("over") } 输出： go run ./demo.go once 9 测试如果不添加once.Do 这段代码，则会输出如下结果，并且每次执行的输出都不一样。 once 9 once 0 once 3 once 6 once 4 once 1 once 5 once 2 once 7 once 8 从两次输出不同，我们可以得知 sync.Once的作用是：保证传入的函数只执行一次 二. 源码分析 2.1结构体 Once的结构体如下 type Once struct { done uint32 m Mutex } 每一个 sync.Once 结构体中都只包含一个用于标识代码块是否执行过的 done 以及一个互斥锁 sync.Mutex 2.2 接口 sync.Once.Do 是 sync.Once 结构体对外唯一暴露的方法，该方法会接收一个入参为空的函数： 如果传入的函数已经执行过，会直接返回 如果传入的函数没有执行过， 会调用sync.Once.doSlow执行传入的参数 func (o *Once) Do(f func()) { // Note: Here is an incorrect implementation of Do: // // if atomic.CompareAndSwapUint32(&o.done, 0, 1) { // f() // } // // Do guarantees that when it returns, f has finished. // This implementation would not implement that guarantee: // given two simultaneous calls, the winner of the cas would // call f, and the second would return immediately, without // waiting for the first's call to f to complete. // This is why the slow path falls back to a mutex, and why // the atomic.StoreUint32 must be delayed until after f returns. if atomic.LoadUint32(&o.done) == 0 { // Outlined slow-path to allow inlining of the fast-path. o.doSlow(f) } } 代码注释中特别给了一个说明: 很容易犯错的一种实现 if atomic.CompareAndSwapUint32(&o.done, 0, 1) { f() } 如果这么实现最大的问题是，如果并发调用，一个 goroutine 执行，另外一个不会等正在执行的这个成功之后返回，而是直接就返回了，这就不能保证传入的方法一定会先执行一次了 正确的实现方式 if atomic.LoadUint32(&o.done) == 0 { // Outlined slow-path to allow inlining of the fast-path. o.doSlow(f) } 会先判断 done 是否为 0，如果不为 0 说明还没执行过，就进入 doSlow func (o *Once) doSlow(f func()) { o.m.Lock() defer o.m.Unlock() if o.done == 0 { defer atomic.StoreUint32(&o.done, 1) f() } } 在 doSlow 当中使用了互斥锁来保证只会执行一次 具体的逻辑 为当前Goroutine获取互斥锁 执行传入的无入参函数； 运行延迟函数， 将成员变量done更新为1 三. 使用场景案例 3.1 单例模式 原子操作配合互斥锁可以实现非常高效的单件模式。互斥锁的代价比普通整数的原子读写高很多，在性能敏感的地方可以增加一个数字型的标志位，通过原子检测标志位状态降低互斥锁的使用次数来提高性能。 type singleton struct {} var ( instance *singleton initialized uint32 mu sync.Mutex ) func Instance() *singleton { if atomic.LoadUint32(&initialized) == 1 { return instance } mu.Lock() defer mu.Unlock() if instance == nil { defer atomic.StoreUint32(&initialized, 1) instance = &singleton{} } return instance } 而使用sync.Once能更简单实现单例模式 type singleton struct {} var ( instance *singleton once sync.Once ) func Instance() *singleton { once.Do(func() { instance = &singleton{} }) return instance } 3.2 加载配置文件示例 延迟一个开销很大的初始化操作到真正用到它的时候再执行是一个很好的实践。因为预先初始化一个变量（比如在init函数中完成初始化）会增加程序的启动耗时，而且有可能实际执行过程中这个变量没有用上，那么这个初始化操作就不是必须要做的。我们来看一个例子： var icons map[string]image.Image func loadIcons() { icons = map[string]image.Image{ "left": loadIcon("left.png"), "up": loadIcon("up.png"), "right": loadIcon("right.png"), "down": loadIcon("down.png"), } } // Icon 被多个goroutine调用时不是并发安全的 // 因为map类型本就不是类型安全数据结构 func Icon(name string) image.Image { if icons == nil { loadIcons() } return icons[name] } 多个goroutine并发调用Icon函数时不是并发安全的，编译器和CPU可能会在保证每个goroutine都满足串行一致的基础上自由地重排访问内存的顺序。loadIcons函数可能会被重排为以下结果： func loadIcons() {     icons = make(map[string]image.Image)     icons["left"] = loadIcon("left.png")     icons["up"] = loadIcon("up.png")     icons["right"] = loadIcon("right.png")     icons["down"] = loadIcon("down.png") } 在这种情况下就会出现即使判断了icons不是nil也不意味着变量初始化完成了。考虑到这种情况，我们能想到的办法就是添加互斥锁，保证初始化icons的时候不会被其他的goroutine操作，但是这样做又会引发性能问题。 可以使用sync.Once 改造代码 var icons map[string]image.Image var loadIconsOnce sync.Once func loadIcons() { icons = map[string]image.Image{ "left": loadIcon("left.png"), "up": loadIcon("up.png"), "right": loadIcon("right.png"), "down": loadIcon("down.png"), } } // Icon 是并发安全的,并且保证了在代码运行的时候才会加载配置 func Icon(name string) image.Image { loadIconsOnce.Do(loadIcons) return icons[name] } 这样设计就能保证初始化操作的时候是并发安全的并且初始化操作也不会被执行多次。 四.总结 作为用于保证函数执行次数的 sync.Once 结构体，它使用互斥锁和 sync/atomic 包提供的方法实现了某个函数在程序运行期间只能执行一次的语义。在使用该结构体时，我们也需要注意以下的问题： sync.Once.Do 方法中传入的函数只会被执行一次，哪怕函数中发生了 panic； 两次调用 sync.Once.Do 方法传入不同的函数只会执行第一次调传入的函数； 五. 参考 https://lailin.xyz/post/go-training-week3-once.html https://www.topgoer.cn/docs/gozhuanjia/chapter055.2-waitgroup https://www.topgoer.com/并发编程/sync.html https://chai2010.cn/advanced-go-programming-book/ch1-basic/ch1-05-mem.html 到此这篇关于GoGo语言 ......查看全文

前言 今天的文章比较基础，但却是必须掌握的，而且本文有些内容，也许你之前没想过。希望这篇文章能够让你理解环境变量并掌握 Go 环境变量相关操作。 01 从安装 Go 说起 其实不止是安装 Go，其他语言一本也会有类似的问题。一般来说，安装完 Go 后，会建议将 go 可执行程序配置到 PATH 环境变量中。 比如我本地的 PATH 环境变量的值： $ echo $PATH /Users/xuxinhua/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Applications/Wireshark.app/Contents/MacOS:/Users/xuxinhua/.cargo/bin:/Users/xuxinhua/bin:/usr/local/git/bin:/Users/xuxinhua/.composer/vendor/bin:/Users/xuxinhua/go/bin 那么 PATH 环境变量的作用是什么呢？ 简单一句话就是，让你在终端执行命令时，不需要输入绝对路径。比如 Go 安装在了 ~/.go/bin 目录下，如果我们要执行 Go 命令，得类似这样： $ ~/.go/bin/go version 是不是很麻烦？！但将 ~/.go/bin 目录加入到 PATH 环境变量后，可以直接这样执行 Go 命令： $ go version 这就是 PATH 环境变量的作用：告知去哪里查找要执行的命令。 那么环境变量的作用是什么呢？百科上关于环境变量的解释： 环境变量（environment variables）一般是指在操作系统中用来指定操作系统运行环境的一些参数，如：临时文件夹位置和系统文件夹位置等。 进程也会有自己的环境变量，一般从父进程继承，也可以人为指定。比如在终端运行某个程序时，可以给它传递环境变量： $ NAME=polarisxu ./xxx 进程中就可以通过 NAME 获取到 polarisxu 这个值。 环境变量可以说无处不在，很多时候只是我们没有细想而已。 注：因为 PATH 环境变量的作用机制，在 Shell、Dockerfile 等中，你需要时刻意识到，PATH 环境变量的值是什么，有没有包含你的命令路径，对于这样的场景，可能更好的办法是写绝对路径，而不是依赖 PATH。 02 Go 如何使用环境变量 很多大型应用程序，会使用环境变量进行配置（当然也支持其他方式配置，比如 flag）。作为配置选项的环境变量大大简化了应用程序的部署。这些在云基础设施中也很常见。 通常，基于环境变量的配置，如果环境变量没设置，程序会有一个默认值。 在 Go 语言中，和环境变量相关的 API 主要在 os 包中。下面的 API 都加上了注释。 // Environ 以 key=value 的形式返回所有环境变量。 func Environ() []string // ExpandEnv 根据当前环境变量的值替换字符串中的 ${var} 或 $var。 // 对未定义变量的引用将被空字符串替换。 func ExpandEnv(s string) string // Getenv 检索 key 这个键对应的环境变量的值。 // 如果该环境变量不存在，返回空字符串。 // 要区分空值和未设置值，请使用 LookupEnv。 func Getenv(key string) string // LookupEnv 检索 key 这个键对应的环境变量的值。 // 如果该环境变量存在，则返回对应的值(可能为空)，并且布尔值为 true。 // 否则，返回值将为空，布尔值将为 false。 func LookupEnv(key string) (string, bool) // Setenv 设置 key 这个键对应的环境变量的值。 // 如果出错会返回错误。 func Setenv(key, value string) error // Unsetenv 取消设置单个环境变量。 func Unsetenv(key string) error // Clearenv 将删除所有环境变量。 func Clearenv() 此外，os/exec 中有一个 LookPath 函数，和 PATH 环境变量有关： // 在 PATH 环境变量对应的目录中搜索名为 file 的可执行文件。 // 如果文件包含 /，则不会搜索 PATH，而是正常路径查找。 // 返回的结果可能是绝对路径或相对于当前目录的相对路径。 func LookPath(file string) (string, error) 现在，通过一个例子看看这些 API 如何使用。 // main.go package main import ( "fmt" "os" ) func main() { name := os.Getenv("NAME") fmt.Println("name is:", name) } 然后运行： $ NAME=polarisxu go run main.go name is: polarisxu 如果前面的 NAME=polarisxu 没有，则返回的 name 是空字符串。如果希望有默认值，该怎么做？ package main import ( "fmt" "os" ) func main() { name := GetenvDefault("NAME", "xuxinhua") fmt.Println("name is:", name) } func GetenvDefault(key, defVal string) string { val, ok := os.LookupEnv(key) if ok { return val } return defVal } 通过 os.LookupEnv 可以得到是否设置了环境变量。这时运行 go run main.go 的结果会是：name is: xuxinhua。 以上就是 Go 中会常用到获取环境变量的 API。 其他 API，用到的可能性不大。有两个 API 值得提一下：Environ() 和 ExpandEnv()。 前面提到过，进程会从父进程继承环境变量。这里最重要的就是 PATH 环境变量。有时候，我们通过 os/exec 包执行外部程序时，可能会提示找不到命令，这时需要确认 PATH 是否正确。可能 Shell 下 PATH 包含了命令所在目录，但进程可能没包含，我们可以在程序中输出所有环境变量： envs := os.Environ() for _, env := range envs { fmt.Println(env) } 一行是一个完整的环境变量，比如 LANG=zh_CN.UTF-8。 再看下 ExpandEnv() 函数。有以下代码：（省略 main 相关其他代码） host := os.ExpandEnv("127.0.0.1:$PORT") fmt.Println(host) IP:PORT 的形式是常见的，通常，我们会做字符串拼接：host + ":" + port，有了 os.ExpandEnv，不需要进行拼接了，它会将 $PORT 替换为 os.Getenv("PORT") 的值。 03 小结 环境变量你会用了吗？ 本文没有通过代码试验的其他函数，建议你可以写代码试试，比如看看 os.Clearenv、os.Unsetenv 能不能删除环境变量。 到此这篇关于Go语言获取与设置环境变量的文章就介绍到这了,更多相关Go设置环境变量内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

先来看这样一段代码，所存在的问题： var wg sync.WaitGroup var x int64 func main() { wg.Add(2) go f() go f() wg.Wait() fmt.Println(x) // 输出：12135 } func f() { for i:=0;i<10000;i++ { x = x+1 } wg.Done() } 这里为什么输出是 12135（不同的机器结果不一样），而不是20000。 因为 x 的赋值，总共分为三个步骤：取出x的值、计算x的结果、给x赋值。那么由于对于f函数的调用采用了goroutine协程，所以存在资源竞争的问题，所以有赋值和计算过程中存在脏数据。对于此类的问题，可以采用互斥锁解决： 互斥锁 互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。Go语言中使用sync包的Mutex类型来实现互斥锁。 var wg sync.WaitGroup var x int64 var lock sync.Mutex func main() { wg.Add(2) go f() go f() wg.Wait() fmt.Println(x) // 输出：20000 } func f() { for i:=0;i<10000;i++ { lock.Lock() // 加互斥锁 x = x+1 lock.Unlock() // 解锁 } wg.Done() } 使用互斥锁能够保证同一时间有且只有一个goroutine进入临界区，其他的goroutine则在等待锁；当互斥锁释放后，等待的goroutine才可以获取锁进入临界区，多个goroutine同时等待一个锁时，唤醒的策略是随机的。 读写互斥锁 互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。读写锁在Go语言中使用sync包中的RWMutex类型。 读写锁分为两种：读锁和写锁。当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁会继续获得锁，如果是获取写锁就会等待；当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是写锁都会等待。 var ( x1 int64 wg1 sync.WaitGroup lock1 sync.Mutex rwlock sync.RWMutex ) func main() { startTime := time.Now() for i:=0;i<100;i++ { wg1.Add(1) write() } for i:=0;i<10000;i++ { wg1.Add(1) read() } wg1.Wait() fmt.Println(time.Now().Sub(startTime)) // 互斥锁用时： 973.9304ms // 读写互斥锁用时： 718.094ms } func read() { defer wg1.Done() //lock1.Lock() // 互斥锁 rwlock.RLock() // 读写互斥锁 fmt.Println(x1) //lock1.Unlock() // 互斥锁 rwlock.RUnlock() // 读写互斥锁 } func write() { defer wg1.Done() lock1.Lock() x1 = x1+1 lock1.Unlock() } 到此这篇关于Go 互斥锁和读写互斥锁的实现的文章就介绍到这了,更多相关Go语言 互斥锁和读写互斥锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言 在 Golang 中 map 不是并发安全的，自 1.9 才引入了 sync.Map ，sync.Map 的引入确实解决了 map的并发安全问题，不过 sync.Map 却没有实现 len() 函数，如果想要计算 sync.Map 的长度，稍微有点麻烦，需要使用 Range 函数。 map 并发操作出现问题 func main() { demo := make(map[int]int) go func() { for j := 0; j < 1000; j++ { demo[j] = j } }() go func() { for j := 0; j < 1000; j++ { fmt.Println(demo[j]) } }() time.Sleep(time.Second * 1) } 执行输出： fatal error: concurrent map read and map write sync.Map 解决并发操作问题 func main() { demo := sync.Map{} go func() { for j := 0; j < 1000; j++ { demo.Store(j, j) } }() go func() { for j := 0; j < 1000; j++ { fmt.Println(demo.Load(j)) } }() time.Sleep(time.Second * 1) } 执行输出： <nil> false 1 true ... 999 true 计算 map 长度 func main() { demo := make(map[int]int) for j := 0; j < 1000; j++ { demo[j] = j } fmt.Println("len of demo:", len(demo)) } 执行输出： len of demo: 1000 计算 sync.Map 长度 func main() { demo := sync.Map{} for j := 0; j < 1000; j++ { demo.Store(j, j) } lens := 0 demo.Range(func(key, value interface{}) bool { lens++ return true }) fmt.Println("len of demo:", lens) } 执行输出： len of demo: 1000 小结 Load 加载 key 数据 Store 更新或新增 key 数据 Delete 删除 key 数据 Range 遍历数据 LoadOrStore 如果存在 key 数据则返回，反之则设置 LoadAndDelete 如果存在 key 数据则删除 到此这篇关于Go使用sync.Map来解决map的并发操作问题的文章就介绍到这了,更多相关Go语言 sync.Map解决map并发操作内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

区块链实战 字节 字段 说明 4 版本区块版本号，表示本区块遵守的验证规则 32 父区块头哈希值 前一区块的Merkle树根的哈希值，同样采取SHA256计算 32 Merkle根 该区块中交易的Merkle树根的哈希值，同样采用SHA256计算 4 时间戳 该区块产生的近似时间，精确到秒的UNIX时间戳，必须严格大于前11各区块的时间的中值，同时全节点也会拒接那些超过自己两个小时的时间戳的区块 4 难度目标 该区块工作量证明算法的难度目标，已经使用特定算法编码 4 Nonce 未来找到满足难度目标所设定的随机数，为了解决32为随机数在算力飞升的情况下不够用的问题，规定时间戳和coinbase交易信息均改变，以此扩展nonce的位数 注意：区块不存储hash值，节点接受区块后独立计算并存储在本地。 Version 1 区块相关： ​ 1.定义一个区块的结构Block ​ a.区块头：6个字段 ​ b.区块体：字符串表示data 2.提供一个创建区块的方法 ​ NewBlock(参数) 区块链相关 定义一个区块链结构BlockChain ​ Block数组 提供一个创建BlockChain()的方法 ​ NewBlockChain() 提供一个添加区块的方法 ​ AddBlock(参数) block.go文件 package main import ( "bytes" "crypto/sha256" "time" ) /* 1.定义一个区块的结构Block ​a.区块头：6个字段 ​b.区块体：字符串表示data */ //区块 type Block struct { Version int64 //版本 PerBlockHash []byte //前一个区块的hash值 Hash []byte //当前区块的hash值，是为了简化代码 MerKelRoot []byte //梅克尔根 TimeStamp int64 //时间抽 Bits int64 //难度值 Nonce int64 //随机值 //区块体 Data []byte //交易信息 } /* 提供一个创建区块的方法 NewBlock(参数) */ func NewBlock(data string ,prevBlockHash []byte) *Block { var block Block block = Block{ Version: 1, PerBlockHash: prevBlockHash, //Hash: []byte{}, //区块不存储hash值，节点接受区块后独立计算并存储在本地。 MerKelRoot: []byte{}, TimeStamp: time.Now().Unix(), Bits: 1, Nonce: 1, Data: []byte(data), } block.SetHash() //填充Hash return &block } func (block *Block) SetHash() { // 源码里面是要传二维切片 func Join(s [][]byte, sep []byte) []byte tmp :=[][]byte{ IntToByte(block.Version), block.PerBlockHash, block.MerKelRoot, IntToByte(block.TimeStamp), IntToByte(block.Bits), IntToByte(block.Nonce), } data:=bytes.Join(tmp,[]byte{}) //之后再计算hash hash := sha256.Sum256(data) block.Hash = hash[:] //变切片 } //创始块 func NewGensisBlock() *Block{ return NewBlock("Genesis Block!",[]byte{}) } blockChain.go文件 package main /* 1. 定义一个区块链结构BlockChain Block数组 */ type BlockChain struct { blocks []*Block } /* 2. 提供一个创建BlockChain()的方法 NewBlockChain() */ func NewBlockChain() *BlockChain { block := NewGensisBlock() return &BlockChain{blocks:[]*Block{block}} //创建只有一个元素的区块链，初始化 } /* 3. 提供一个添加区块的方法 AddBlock(参数) */ func (bc *BlockChain)AddBlock(data string) { PerBlockHash := bc.blocks[len(bc.blocks)-1].Hash //这一个区块的哈希是前一块的哈希值 block := NewBlock(data,PerBlockHash) bc.blocks = append(bc.blocks,block) } utils.go文件 package main import ( "bytes" "encoding/binary" "fmt" "os" ) func IntToByte(num int64) []byte { //func Write(w io.Writer, order ByteOrder, data interface{}) error { var buffer bytes.Buffer err := binary.Write(&buffer, binary.BigEndian, num) CheckErr("IntToByte",err) return buffer.Bytes() } func CheckErr(position string,err error) { if err != nil { fmt.Println("error ,pos:",position,err) os.Exit(1) } } main.go文件 package main import "fmt" func main() { bc := NewBlockChain() bc.AddBlock("A send B 1BTC") bc.AddBlock("B send C 1BTC") for _,block := range bc.blocks { fmt.Printf("Version : %d\n",block.Version) fmt.Printf("PerBlockHash : %x\n",block.PerBlockHash) fmt.Printf("Hash : %x\n",block.Hash) fmt.Printf("MerKelRoot : %x\n",block.MerKelRoot) fmt.Printf("TimeStamp : %d\n",block.TimeStamp) fmt.Printf("Bits : %d\n",block.Bits) fmt.Printf("Nonce : %d\n",block.Nonce) fmt.Printf("Data : %s\n",block.Data) } } 执行结果 以上就是Go语言语言区块链实战实现简单的区块与区块链的详细内容，更多关于go语言实现区块与区块链的资料请关注M135模板网其它相关文章！ ......查看全文

geth 以太坊智能合约开发中最常用的命令行工具。 Geth是由以太坊基金会提供的官方客户端软件，用Go编程语言编写的。Geth提供了一个交互式命令控制台，通过命令控制台中包含了以太坊的各种功能（API）。全名go-ethereum。 1. geth 简介 1.1 下载地址： 官网（很慢）：https://geth.ethereum.org/downloads/ 国内镜像：https://ethfans.org/wikis/Ethereum-Geth-Mirror 1.2 安装： 下载下来之后，会在安装目录生成geth.exe 将这个文件放在gopath的bin目录中， 放在这里就行了 1.3 查看是否安装成功 geth version 如果你安装了，但是没有显示这个的话，可能是因为你的系统环境里面没有go的路径，把go的bin目录路径放在系统变量的path就好了~ 2. geth命令介绍 geth -help查看帮助 命 令：geth [选项] 命令 [命令选项] [参数…] 命令参数介绍：超详细 3. geth常用命令 3.1 指定数据目录 --datadir 如：geth --datadir “路径” account new 3.2 账户相关 查看账户：geth account list 查看账户的信息 创建账户：geth account new 然后输入两次密码 更新指定账户：geth account update "用户地址" 输入账户密码及确认密码 默认是会把用户的账户信息存放在这个目录 导入账户：geth account import 你的私钥文件路径(导出私钥存放到xx.txt) 指定保存路径的创建用户：geth --datadir account new 3.3 控制台console： 启动并进入交互式javascript环境 默认连接的是ipc geth attach http://IP:8545，默认不开启 geth attach ws://IP:8546，默认不开启 进入控制台：geth console 可以指定--datadir "路径" 退出控制台：exit 或者 ctrl+d 常用api： 获取区块号：eth.blockNumber 是否在监听端口 net.listening 开始挖矿：miner.start() 挖矿还可以指定进程数：miner.start(1) 停止挖矿：miner.stop() 检查是否在挖矿：eth.mining true：在挖矿，false：不在挖矿 获取账户地址数组：eth.accounts 获取挖矿地址：eth.coinbase 默认第一个创建的账户 查看第一个账户余额：eth.getBalance(eth.accounts[0]) 创建用户：personal.newAccount(“12345678”) 设置挖矿账户：miner.setEtherbase(“地址A”) 账户间转钱：eth.sendTransation({from:“地址A”,to:“地址B”,value:web3.toWei(10,“ether”)}) 获取交易信息：eth.getTransaction(‘地址A') 3.4 删除数据： 不要直接删除datadir目录，使用removedb geth --datadir "路径" removedb 这会删除路径/geth/chaindata，其他东西都不会动，不会删除用户。 3.5 help geth account -hgeth account help new 查看子命令 3.6 常见错误 1 . Error: authentication needed: password or unlock undefined： 这种报错解锁下账户即可 账户解锁：personal.unlockAccount(“账户地址”) 2 . Returned error: exceeds block gas limit： 出现这种错误就看块号的gaslimit，部署时改成一直 获取块号：eth.blockNumber 根据块号获取详细信息：eth.getBlock(0)  4. Go语言调用合约 4.1 启动rpc端口 geth --datadir "fanone" --identity "fanone" --rpc --rpcport 8545 --rpcapi "db,eth,net,web3,personal" --rpccorsdomain "*" console –identity “fanone”：节点身份标识 –rpc：开启 RPC 接口 –rpcport：RPC 端口，默认go是8545 –rpcapi “db,eth,net,web3”：提供给别人使用的 RPC API，默认为web3接口 –rpccorsdomain：设置能连接到你的节点的 URL，用来完成RPC任 务。* 指任何URL都能连接到,默认只能自己连接 –datadir：区块数据文件夹 ，如果不指定的话，就是上面的那个在C盘的地址。 为了C盘着想，所以还是建议这样，新建一个文件夹放在其他盘 就会在这里进行存放了 –networkid：net_version的id –port：用来监听其他节点的端口 –nodiscover：你的节点不会被其他人发现，除非他们手动添加你 是连接这个url 4.2 Go调用以太坊 下载包："github.com/ethereum/go-ethereum/rpc" 示例代码： client, _ := rpc.Dial("http://localhost:8545") var result bool client.Call(&result ,"net_listening") // 注意这里必须使用指针，否则会报空指针异常 启动之后 在go中调用 4.3 调用接口 net_version 当前连接网络的ID net_version： 当前连接网络的ID var networkid string client.Call(&networkid,"net_version") networkid： "1":Mainnet "2": Morden Testnet "3": Ropsten Testnet "4": Rinkeby Testnet "42": Kovan Testnet 在启动rpc服务接口的时候可以指定： --networkid net_listening 客户端是否处于监听状态 var is_listing bool client.Call(&is_listing,"net_listening") net_peerCount 所连接对端节点旳数量 var count string client.Call(&count,"net_peerCount") //"0x0" 表示0个 //"0x2" 表示2个 eth接口 1 .eth_accounts：账户地址数组 var accounts []string client.Call(&accounts,"eth_accounts") 2 .eth_getBalance:获取指定地址账户的余额，单位：wei var balance string client.Call(&balance,"eth_getBalance","0x558c90c05d8c4b55a87de03bd601fd76faf50f9b","latest") 参数： 账户地址 整数块编号，或者字符串"latest", “earliest” 或 “pending” 3 .eth_gasPrice：返回当前的gas价格，单位：wei。 var gas_price string client.Call(&gas_price,"eth_gasPrice") 4.eth_coinbase： 获取挖矿账户地址 var coinbase string client.Call(&coinbase, "eth_coinbase") 5.eth_protocolVersion： 返回当前以太坊协议的版本。 var proto_version string client.Call(&proto_version , "eth_protocolVersion") 6.eth_mining： 客户端是否在挖矿中 var is_mining bool client.Call(&is_mining,"eth_mining") 7.eth_hashrate： 返回节点挖矿时每秒可算出的哈希数量。 var hashrate string client.Call(&hashrate,"eth_hashrate") 8.eth_getTransactionCount： 返回指定地址发生的交易数量 var transactionCount string client.Call(&transactionCount,"eth_getBalance","0x72w12d05d8c4b55a87de03bd601fd76faf50f9b","latest") //参数 // 账户地址 // 整数块编号，或者字符串"latest", "earliest" 或 "pending" 9.eth_blockNumber：获取节点当前块编号 var blockNum string client.Call(&blockNum ,"eth_blockNumber") personal接口 1 .personal_listAccounts： 获取该节点下的所有账户，和eth_accounts效果一样 var accounts []string client.Call(&accounts,"personal_listAccounts") 2.personal_newAccount： 创建用户 var newAccount string client.Call(&newAccount, "personal_newAccount", "12345678") 参数： 密码 3.personal_lockAccount： 锁定指定账户 var is_lock bool client.Call(&is_lock, "personal_lockAccount", "账户地址") //参数： // 账户地址 4.personal_unlockAccount： 解锁指定账户,有些操作必须解锁账户才可以操作 var is_unlock bool client.Call(&is_unlock, "personal_lockAccount", "账户地址","账户密码") 参数： 账户地址 账户密码 db接口 1.db_putString： 在本地数据库中存入字符串 var is_ok bool client.Call(&is_ok, "db_putString", "db_name","key",""value") 参数： 数据库名称 key名 要存入的字符串值 2.db_getString： 从本地数据库读取字符串。 var val string client.Call(&val, "db_getString", "db_name","key") //参数： // 数据库名称 // key名 以上就是Go语言语言区块链学习调用以太坊的详细内容，更多关于go语言区块链调用以太坊的资料请关注M135模板网其它相关文章！ ......查看全文

1. 获取abi文件 合约的接口 在remix工具中编译合约后，会有一个abi，复制 然后新建一个xx.abi文件，把赋值的粘贴到里面 注意：代码变了，重新编译后abi也会变，所以一定要用最新的abi 也可以通过solc生成abi： solc --bin test.sol -o test.abi 2. 安装abigen工具 用来生成go文件， 下载文件：github地址 找到这个main.go文件，进行go build，生成abigen.exe文件。 然后放在bin目录下的这里 然后就可以在这里验证了 使用abigen工具生成go文件 abigen --abi xx.abi --pkg packagename --type structname --out xx.go abi 文件在 remix 部署时可以得到pkg 指定输出文件的包名，也就是package 名称type 指定合约结构体名称out 指定输出go文件名称 3. remix连接私有链 geth启动私链，要指定rpccorsdomain *，不然在remix中是连接不上的。 选择Web3 Provider方式，默认连接私有链8545端口 但是可以看到我们这里是没有account的 所以我们可以创建一个account 创建了两个之后 就可以在这里看见了。 4. 合约部署 1.连接私有链：选择Web3 Provider，默认端口号时8545，如果geth启动的rpc端口号不一致，改成一致 2.部署合约 可能会出现下面几种错误，依此列出解决办法 1 .Error: authentication needed: password or unlock：这种报错解锁下账户即可 账户解锁：personal.unlockAccount(“账户地址”) unlock一下就行了 2 .Returned error: exceeds block gas limit：出现这种错误就看块号的gaslimit，部署时改成一直 获取块号：eth.blockNumber 根据块号获取详细信息：eth.getBlock(0) 会看到gasLimit的值，在部署时的gaslimit不能大于这个 3 .Returned error: insufficient funds for gas * price + value：部署合约需要手续费，得赚取，通过挖矿 没钱， 要挖矿赚钱。 开启指定线程数挖矿：miner.start(1) 停止挖矿：miner.stop() 检查是否在挖矿：eth.mining true：在挖矿，false：不在挖矿 获取账户地址数组：eth.accounts 获取挖矿地址：eth.coinbase 默认第一个创建的账户 查看第一个账户余额：eth.getBalance(eth.accounts[0]) 获取指定账户的余额：eth.getBalance(“账户地址”) 5. 初始化私有链节点创世块 新建一个genesis.json文件，内容如下 { "config":{ "chainId":15, "homesteadBlock":0, "eip155Block":0, "eip158Block":0 }, "coinbase":"0x0000000000000000000000000000000000000000", "difficulty":"0x40000", "extraData":"", "gasLimit":"0xffffffff", "nonce":"0x0000000000000042", "mixhash":"0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "timestamp":"0x00", "alloc":{ } } 含义： coinbase：挖矿账户地址，随便填，后面可以设置，一般默认第一个创建的用户 difficulty: 设置当前区块的难度，如果难度过大，cpu挖矿就很难，这里设置较小难度 gasLimit: 该值设置对GAS的消耗总量限制，用来限制区块能包含的交易信息总和，填最大即可。 nonce: nonce就是一个64位随机数，用于挖矿，注意他和mixhash的设置需要满足以太坊的Yellow paper mixhash：与nonce配合用于挖矿，由上一个区块的一部分生成的hash。 parentHash: 上一个区块的hash值，因为是创世块，所以这个值是0extraData: timestamp: 设置创世块的时间戳 alloc: 用来预置账号以及账号的以太币数量，因为私有链挖矿比较容易，所以我们不需要预置有币的账号，需要的时候自己创建即可以。 cmd进入到存放json文件的路径 geth -datadir "fanone" init genesis.json 6. 合约部署 部署时候需要支付手续费 http://ethscan.hubwiz.com/ 7. 调用 github.com/ethereum/go-ethereum v1.10.0 package main import ( "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/common" "eth_block/utils/contract/abi" "fmt" "github.com/ethereum/go-ethereum/accounts/abi/bind" ) func main() { // 连接rpc client,err := ethclient.Dial("http://127.0.0.1:8545") // 定义要操作合约的账户地址 addr := "0x29794ab2ed6c47faff7ebdd6dcdd71a263e25460" // 将字符串地址转为common.Address common_addr := common.HexToAddress(addr) if err != nil { panic("连接以太坊合约出错") } // 创建合约对象 contract_obj,err11 := contract.NewTestAddress(common_addr,client) if err11 !=nil { panic("创建合约对象出错") } fmt.Println(contract_obj.TestAddressCaller) // Caller访问函数 fmt.Println(contract_obj.TestAddressTransactor) // Transactor 有函数 fmt.Println(contract_obj.TestAddressFilterer) // 没什么作用 } 以上就是Go语言语言区块链学习调用智能合约的详细内容，更多关于go语言区块链调用智能合约的资料请关注M135模板网其它相关文章！ ......查看全文

首先可以先看看这篇文章，对锁有些了解 GO语言并发编程之互斥锁、读写锁详解 Mutex-互斥锁 Mutex 的实现主要借助了 CAS指令 + 自旋 + 信号量 数据结构： type Mutex struct { state int32 sema uint32 } 上述两个加起来只占 8 字节空间的结构体表示了 Go语言中的互斥锁 状态： 在默认情况下，互斥锁的所有状态位都是 0，int32 中的不同位分别表示了不同的状态： 1位表示是否被锁定 1位表示是否有协程已经被唤醒 1位表示是否处于饥饿状态 剩下29位表示阻塞的协程数 正常模式和饥饿模式 正常模式：所有goroutine按照FIFO的顺序进行锁获取，被唤醒的goroutine和新请求锁的goroutine同时进行锁获取，通常新请求锁的goroutine更容易获取锁(持续占有cpu)，被唤醒的goroutine则不容易获取到锁 饥饿模式：所有尝试获取锁的goroutine进行等待排队，新请求锁的goroutine不会进行锁获取(禁用自旋)，而是加入队列尾部等待获取锁 如果一个 Goroutine 获得了互斥锁并且它在队列的末尾或者它等待的时间少于 1ms，那么当前的互斥锁就会切换回正常模式。 与饥饿模式相比，正常模式下的互斥锁能够提供更好地性能，饥饿模式的能避免 Goroutine 由于陷入等待无法获取锁而造成的高尾延时。 互斥锁加锁过程 如果互斥锁处于初始状态，会直接加锁 如果互斥锁处于加锁状态，并且工作在普通模式下，goroutine会进入自旋，等待锁的释放 goroutine 进入自旋的条件非常苛刻： 互斥锁只有在普通模式才能进入自旋； runtime.sync_runtime_canSpin需要返回 true 运行在多 CPU 的机器上； 当前 Goroutine 为了获取该锁进入自旋的次数小于四次； 当前机器上至少存在一个正在运行的处理器 P 并且处理的运行队列为空； 如果当前 Goroutine 等待锁的时间超过了 1ms，互斥锁就会切换到饥饿模式； 互斥锁在正常情况下会通runtime.sync_runtime_SemacquireMutex将尝试获取锁的 Goroutine 切换至休眠状态，等待锁的持有者唤醒； 如果当前 Goroutine 是互斥锁上的最后一个等待的协程或者等待的时间小于 1ms，那么它会将互斥锁切换回正常模式； 互斥锁解锁过程 当互斥锁已经被解锁时，再解锁会抛出异常 当互斥锁处于饥饿模式时，将锁的所有权交给等待队列最前面的 Goroutine 当互斥锁处于正常模式时，如果没有 Goroutine 等待锁的释放或者已经有被唤醒的 Goroutine 获得了锁，会直接返回；在其他情况下会通过唤醒对应的 Goroutine； 关于互斥锁锁的使用建议写业务时不能全局使用同一个 Mutex千万不要将要加锁和解锁分到两个以上 Goroutine 中进行Mutex 千万不能被复制（包括不能通过函数参数传递），否则会复制传参前锁的状态：已锁定 or 未锁定。很容易产生死锁，关键是编译器还发现不了这个 Deadlock~ RWMutex-读写锁 Go 中 RWMutex 使用的是写优先的设计 数据结构： type RWMutex struct { w Mutex //复用互斥锁提供的能力 writerSem uint32 //writer信号量 readerSem uint32 //reader信号量 readerCount int32 //存储了当前正在执行的读操作数量 readerWait int32 // 表示写操作阻塞时，等待读操作完成的个数 } 写锁 获取写锁 ： 调用结构体持有的Mutex结构体的Mutex.Lock阻塞后续的写操作 将readerCount减少2^30,成为负数，以阻塞后续读操作 如果有其他Goroutine 持有读锁，该 Goroutine会进入休眠状态等待所有读锁执行结束后释放writerSem信号量将当前协程唤醒 释放写锁： 将readerCount变回正数，释放读锁 唤醒所有因为读锁而睡眠的Goroutine 调用Mutex.Unlock 释放写锁 获取写锁时会先阻塞写锁的获取，后阻塞读锁的获取，这种策略能够保证读操作不会被连续的写操作『饿死』。 读锁 获取读锁 获取读锁的方法 sync.RWMutex.RLock 很简单，该方法会将readerCount加一： 如果该方法返回负数（代表其他 goroutine 获得了写锁，当前 goroutine 就会使其陷入休眠等待锁的释放 如果该方法返回结果为非负数，代表没有 goroutine 获得写锁，会成功返回 释放读锁 解锁读锁的方法sync.RWMutex.RUnlock，该方法会： 将readerCount减一，根据返回值的不同会分别进行处理 如果返回值大于等于0，读锁直接解锁成功 如果小于0代表有正在执行的写操作，会调用sync.RWMutex.rUnlockSlow，将readerWait减一，并且当所有读操作都被释放后触发信号量 writerSem，该信号量被触发时，调度器就会唤醒尝试获取写锁的 Goroutine WaitGroup sync.WaitGroup可以等待一组 Goroutine 的返回 sync.WaitGroup 对外暴露了三个方法： 方法名 功能 (wg * WaitGroup) Add(delta int) 计数器+delta (wg *WaitGroup) Done() 计数器减1 (wg *WaitGroup) Wait() 阻塞直到计数器变为0 sync.WaitGroup.Done只是对 sync.WaitGroup.Add 方法的简单封装，相当于是加 -1 Sync.Map Go语言中内置的map不是并发安全的。 Go语言的sync包中提供了一个开箱即用的并发安全版map–sync.Map。使用互斥锁保证并发安全 数据结构： type Map struct { mu Mutex read atomic.Value // readOnly dirty map[interface{}]*entry misses int } 开箱即用表示不用像内置的map一样使用make函数初始化就能直接使用。同时sync.Map内置了方法: 方法名 功能 (m *sync.Map)Store(key, value interface{}) 保存键值对 (m *sync.Map)Load(key interface{}) 根据key获取对应的值 (m *sync.Map)Delete(key interface{}) 删除键值对 (m *sync.Map)Range(f func(key, value interface{}) bool) 遍历 sync.Map。Range 的参数是一个函数 *sync.map 没有Len( ) 方法 原子操作(atomic包) 代码中的加锁操作因为涉及内核态的上下文切换会比较耗时、代价比较高。针对基本数据类型我们还可以使用原子操作来保证并发安全，因为原子操作是Go语言提供的方法它在用户态就可以完成，因此性能比加锁操作更好。Go语言中原子操作由内置的标准库sync/atomic提供。 参考资料： Go 语言并发编程、同步原语与锁 | Go 语言设计与实现 (draveness.me) 到此这篇关于go语言中并发安全和锁的文章就介绍到这了,更多相关Go语言语言中并发安全和锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、标准库log介绍 Go语言内置的log包实现了简单的日志服务。 1、使用Logger log包定义了Logger类型，该类型提供了一些格式化输出的方法。 log包也提供了一个预定义的“标准”logger，可以通过调用函数Print系列(Print|Printf|Println）、Fatal系列（Fatal|Fatalf|Fatalln）、和Panic系列（Panic|Panicf|Panicln）来使用，比自行创建一个logger对象更容易使用。 logger会打印每条日志信息的日期、时间，默认输出到系统的标准错误。 Fatal系列函数会在写入日志信息后调用os.Exit(1)。 Panic系列函数会在写入日志信息后panic。 示例： // 直接调用print来输出日志到终端 func main() { log.Println("这是一条很普通的日志。") v := "很普通的" log.Printf("这是一条%s日志。\n", v) log.Fatalln("这是一条会触发fatal的日志。") log.Panicln("这是一条会触发panic的日志。") } 2、配置logger  2.1、标准logger的配置 默认情况下的logger只会提供日志的时间信息，但是很多情况下我们希望得到更多信息，比如记录该日志的文件名和行号等。 log标准库中为我们提供了定制这些设置的方法。log标准库中的Flags函数会返回标准logger的输出配置，而SetFlags函数用来设置标准logger的输出配置。 二、自定义日志库  1、需要满足的需求  1、支持网不同地方输出日志 2、日志要支持开关控制 3、完整的日志要包含时间、行号、文件名、日志级别、日志信息 4、日志文件要能切割 5、日志级别 Debug Trace Info Warning Error Fatal 2、了解下runtime包 runtime.Caller() 方法，会返回函数调用的信息，在()内传入int类型数据，代表调用的层数（0代表第一层被调用，1代表第二层，一次类推）。runtime.Caller()返回如下四个参数: pc: 记录了调用的函数消息，如函数名等 file: 调用的文件名 line: 行数 OK: 返回的bool值 // 获取代码行号 func getinfo(n int) { /* runtime.Caller()返回四个参数: pc: 记录了调用的函数消息，如函数名等 file: 调用的文件名 line: 行数 OK: 返回的bool值 */ pc, file, line, ok := runtime.Caller(n) if !ok { fmt.Printf("runtime.Caller() failed\n") return } fmt.Println(pc) // 用于调用函数消息 funcName := runtime.FuncForPC(pc).Name() // 利用 runtime.FuncForPC()方法，参数pc序号，可以调出函数名 fmt.Println(funcName) fmt.Println(file) // 打印出执行的文件的绝对路径 fmt.Println(path.Base(file)) // path.Base()方法可以获取传入的绝对路径的最后一个文件名称 fmt.Println(line) // 打印出执行的行号 } func main() { getinfo(0) } 3、自定义日志库 1、在 E:\GoProject\src\gitee.com 项目目录下，新建 mylogger 包目录，存放日志库代码 在mylogger包目录下console.go文件中，放将日志输出到终端的代码 # E:\GoProject\src\gitee.com\mylogger\console.go package mylogger import ( "fmt" "strings" "time" ) // 终端输出的日志内容 // Logger 日志结构体 type ConsoleLogger struct { Level LogLevel } // 构造函数 func NewLog(levelStr string) ConsoleLogger { level, err := parseLogLevel(levelStr) if err != nil { panic(err) } return ConsoleLogger{ Level: level, } } // 定义日志等级比较 func (c ConsoleLogger) enable(level LogLevel) bool { return c.Level <= level } // 定义一个日志打印方法 func (c ConsoleLogger) outLog(lv LogLevel, format string, a ...interface{}) { level := parseLogLevelStr(lv) if c.enable(lv) { msg := fmt.Sprintf(format, a...) // 支持格式化操作，a...表示对接收的接口进行展开 level = strings.ToUpper(level) fileName, funcName, linenu := getinfo(3) fmt.Printf("[%s] [%s] [FileName:%s lineNum:%d:%s] %s\n", time.Now().Format("2006-01-02 15:04:05"), level, fileName, linenu, funcName, msg) } } // Debug日志 func (c ConsoleLogger) Debug(msg string, a ...interface{}) { c.outLog(DEBUG, msg, a...) } // Info日志 func (c ConsoleLogger) Info(msg string, a ...interface{}) { c.outLog(INFO, msg, a...) } // Warning日志 func (c ConsoleLogger) Warning(msg string, a ...interface{}) { c.outLog(WARNING, msg, a...) } // Error日志 func (c ConsoleLogger) Error(msg string, a ...interface{}) { c.outLog(ERROR, msg, a...) } // Fatal日志 func (c ConsoleLogger) Fatal(msg string, a ...interface{}) { c.outLog(FATAL, msg, a...) } 在mylogger包目录下logfile.go文件中，放将日志输出到文件的代码 # E:\GoProject\src\gitee.com\mylogger\logfile.go package mylogger // 向文件中写日志的相关操作 import ( "fmt" "os" "path" "strings" "time" ) // Logger 日志结构体 type FileLogger struct { Level LogLevel logPath string // 日志文件目录 fileName string // 日志文件名称 maxFileSize int64 // 日志文件大小 fileObj *os.File errFileObj *os.File } // 构造函数 func NewFileLog(levelStr, fp, fn string, maxSize int64) *FileLogger { level, err := parseLogLevel(levelStr) if err != nil { panic(err) } f1 := &FileLogger{ Level: level, logPath: fp, fileName: fn, maxFileSize: maxSize, } err = f1.initFile() if err != nil { panic(err) } return f1 } // 定义文件初始化方法，打开文件 func (f *FileLogger) initFile() error { // 打开文件 fullPath := path.Join(f.logPath, f.fileName) fileObj, err := os.OpenFile(fullPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644) if err != nil { fmt.Printf("open logFile failed,Err:%v", err) return err } // 打开错误日志文件 errFileObj, err := os.OpenFile("error-"+fullPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644) if err != nil { fmt.Printf("open errorLogFile failed,Err:%v", err) return err } // 将文件句柄赋值给结构体中的元素 f.fileObj = fileObj f.errFileObj = errFileObj return nil } // 关闭文件方法 func (f *FileLogger) closeFile() { f.fileObj.Close() f.errFileObj.Close() } // 定义日志等级比较 func (f *FileLogger) enable(level LogLevel) bool { return f.Level <= level } // 定义检查日志大小进行切割的方法 func (f *FileLogger) checkLogSize(file *os.File) bool { // 利用os.Open()方法打开的文件句柄类型都是 *os.File 这种指针类型 fileInfo, err := file.Stat() if err != nil { fmt.Printf("get file info failed,err:%v\n", err) return false // panic(err) } if fileInfo.Size() > f.maxFileSize { return true } return false } func (f *FileLogger) cutFile(file *os.File) (*os.File, error) { // 获取当前文件名 fileInfo, err := file.Stat() if err != nil { fmt.Printf("get file info failed,err:%v\n", err) return nil, err } append := "_" + time.Now().Format("2006-01-02-15-04-05") + ".log" // 时间戳后缀 fileName := fileInfo.Name() newFileName := fileName + append oldPath := path.Join(f.logPath, fileName) // 日志文件的全路径 newPath := path.Join(f.logPath, newFileName) // 关闭当前文件句柄 file.Close() // 进行更名备份 os.Rename(oldPath, newPath) // 再打开一个文件 fileObj, err := os.OpenFile(oldPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644) if err != nil { fmt.Printf("open logFile failed,Err:%v\n", err) return nil, err } return fileObj, nil } // 定义一个日志输出的方法 func (f *FileLogger) outLog(lv LogLevel, format string, a ...interface{}) { level := parseLogLevelStr(lv) if f.enable(lv) { msg := fmt.Sprintf(format, a...) // 支持格式化操作，a...表示对接收的接口进行展开 level = strings.ToUpper(level) fileName, funcName, linenu := getinfo(3) // 判断日志是否需要切割 if f.checkLogSize(f.fileObj) { fileobj, err := f.cutFile(f.fileObj) if err != nil { fmt.Printf("log cut failed,err:%v\n", err) } f.fileObj = fileobj } // 将日志记录在日志文件中 fmt.Fprintf(f.fileObj, "[%s] [%s] [FileName:%s lineNum:%d:%s] %s\n", time.Now().Format("2006-01-02 15:04:05"), level, fileName, linenu, funcName, msg) if lv >= ERROR { // 判断错误日志是否需要切割 if f.checkLogSize(f.errFileObj) { fileobj, err := f.cutFile(f.errFileObj) if err != nil { fmt.Printf("log cut failed,err:%v\n", err) } f.errFileObj = fileobj } // 将日志等级大于ERROR的在错误日志中再记录一遍 fmt.Fprintf(f.errFileObj, "[%s] [%s] [FileName:%s lineNum:%d:%s] %s\n", time.Now().Format("2006-01-02 15:04:05"), level, fileName, linenu, funcName, msg) } } } // Debug日志 func (f *FileLogger) Debug(msg string, a ...interface{}) { f.outLog(DEBUG, msg, a...) } // Info日志 func (f *FileLogger) Info(msg string, a ...interface{}) { f.outLog(INFO, msg, a...) } // Warning日志 func (f *FileLogger) Warning(msg string, a ...interface{}) { f.outLog(WARNING, msg, a...) } // Error日志 func (f *FileLogger) Error(msg string, a ...interface{}) { f.outLog(ERROR, msg, a...) } // Fatal日志 func (f *FileLogger) Fatal(msg string, a ...interface{}) { f.outLog(FATAL, msg, a...) } 在mylogger包目录下创建mylogger.go文件，放包内共用的代码 # E:\GoProject\src\gitee.com\mylogger\mylogger.go package mylogger import ( "errors" "fmt" "path" "runtime" "strings" ) // 设置日志级别 type LogLevel uint16 const ( UNKNOWN LogLevel = iota DEBUG TRACE INFO WARNING ERROR FATAL ) // 解析日志等级，将字符串解析成int func parseLogLevel(s string) (LogLevel, error) { s = strings.ToLower(s) // 将字符串全部转为小写 switch s { case "debug": return DEBUG, nil case "trace": return TRACE, nil case "info": return INFO, nil case "warning": return WARNING, nil case "error": return ERROR, nil case "fatal": return FATAL, nil default: err := errors.New("无效日志等级") return UNKNOWN, err } } // 将日志等级解析成字符串 func parseLogLevelStr(lv LogLevel) (s string) { s = strings.ToLower(s) // 将字符串全部转为小写 switch lv { case DEBUG: return "DEBUG" case TRACE: return "TRACE" case INFO: return "INFO" case WARNING: return "WARNING" case ERROR: return "ERROR" case FATAL: return "FATAL" default: return "DEBUG" } } // 获取代码行号 func getinfo(n int) (fileName, funcName string, line int) { /* runtime.Caller()返回四个参数: pc: 记录了调用的函数消息，如函数名等 file: 调用的文件名 line: 行数 OK: 返回的bool值 */ pc, file, line, ok := runtime.Caller(n) if !ok { fmt.Printf("runtime.Caller() failed\n") return } fileName = path.Base(file) funcName = runtime.FuncForPC(pc).Name() return fileName, funcName, line } 2、调用日志库代码测试 需要注意，导入mylogger包，是从$GOPATH路径开始的（即从src目录开始的相对路径） # E:\GoProject\src\gitee.com\LTP\logging package main import ( "time" mylogger "gitee.com/mylogger" ) func main() { id := 10 name := "小明" flogger := mylogger.NewFileLog("info", "./", "app.log", 1024) for { flogger.Warning("这是个Warning日志") flogger.Error("这是个Error日志,id:%d name:%s", id, name) time.Sleep(2 * time.Second) } } 到此这篇关于Go语言 log日志库的文章就介绍到这了,更多相关Go log日志库内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

背景 通常我们处理文件都是用python+pandas，确实很香。但是今天突然有人找我用go写一个合并两个csv文件的，需要将两个csv按id进行合并，大致如下图 思路很简单，先读入两个csv文件，然后遍历比较id，如果相同就把另一个文件的内容加到第一个中。然后创建merge.csv，将上一步得到的数据写入csv即可。 代码部分 package main import ( "encoding/csv" "log" "os" "fmt" ) func join(fileName1 string, fileName2 string) (row [][]string) { fs1, _ := os.Open(fileName1) r1 := csv.NewReader(fs1) content1, err := r1.ReadAll() if err != nil { log.Fatalf("can not readall, err is %+v", err) } fs2, _ := os.Open(fileName2) r2 := csv.NewReader(fs2) content2, err := r2.ReadAll() if err != nil { log.Fatalf("can not readall, err is %+v", err) } row = make([][]string, len(content1[1:])) for i, row1 := range content1[1:] { for _, row2 := range content2[1:] { if row1[0] == row2[0] { row[i] = append(row[i], row1[0], row1[1], row1[2], row2[1], row2[2]) } } } return } func edit(filename string, row [][]string) { f, err := os.Create(filename) if err != nil { panic(err) } defer f.Close() //防止乱码 f.WriteString("\xEF\xBB\xBF") w := csv.NewWriter(f) w.Write([]string{"ID", "name", "gender", "course", "score"}) w.WriteAll(row) w.Flush() } func main() { row := join("1.csv", "2.csv") fmt.Println(row) edit("join.csv", row) fmt.Println("合并已完成！") } 优化 对于小数据量这样是没有问题，但是一旦数据量增大，不仅读取的内存占用增加，而且遍历比较会很消耗时间。所以优化的话我们可以以行读取，并且想办法使用go的goroutine来增加速度。唉，太久没怎么写go了，一开始切片都有点忘了。 到此这篇关于Go来合并两个csv的实现示例的文章就介绍到这了,更多相关Go语言合并csv内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言 日常开发中我们大概率会遇到超时控制的场景，比如一个批量耗时任务、网络请求等；一个良好的超时控制可以有效的避免一些问题（比如 goroutine 泄露、资源不释放等）。 Timer 在 go 中实现超时控制的方法非常简单，首先第一种方案是 Time.After(d Duration)： func main() { fmt.Println(time.Now()) x := <-time.After(3 * time.Second) fmt.Println(x) } output: 2021-10-27 23:06:04.304596 +0800 CST m=+0.000085653 2021-10-27 23:06:07.306311 +0800 CST m=+3.001711390 time.After() 会返回一个 Channel，该 Channel 会在延时 d 段时间后写入数据。 有了这个特性就可以实现一些异步控制超时的场景： func main() { ch := make(chan struct{}, 1) go func() { fmt.Println("do something...") time.Sleep(4*time.Second) ch<- struct{}{} }() select { case <-ch: fmt.Println("done") case <-time.After(3*time.Second): fmt.Println("timeout") } } 这里假设有一个 goroutine 在跑一个耗时任务，利用 select 有一个 channel 获取到数据便退出的特性，当 goroutine 没有在有限时间内完成任务时，主 goroutine 便会退出，也就达到了超时的目的。 output: do something... timeout timer.After 取消，同时 Channel 发出消息，也可以关闭通道等通知方式。 注意 Channel 最好是有大小，防止阻塞 goroutine ，导致泄露。 Context 第二种方案是利用 context，go 的 context 功能强大； 利用 context.WithTimeout() 方法会返回一个具有超时功能的上下文。 ch := make(chan string) timeout, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() go func() { time.Sleep(time.Second * 4) ch <- "done" }() select { case res := <-ch: fmt.Println(res) case <-timeout.Done(): fmt.Println("timout", timeout.Err()) } 同样的用法，context 的 Done() 函数会返回一个 channel，该 channel 会在当前工作完成或者是上下文取消生效。 timout context deadline exceeded 通过 timeout.Err() 也能知道当前 context 关闭的原因。 goroutine 传递 context 使用 context 还有一个好处是，可以利用其天然在多个 goroutine 中传递的特性，让所有传递了该 context 的 goroutine 同时接收到取消通知，这点在多 go 中应用非常广泛。 func main() { total := 12 var num int32 log.Println("begin") ctx, cancelFunc := context.WithTimeout(context.Background(), 3*time.Second) for i := 0; i < total; i++ { go func() { //time.Sleep(3 * time.Second) atomic.AddInt32(&num, 1) if atomic.LoadInt32(&num) == 10 { cancelFunc() } }() } for i := 0; i < 5; i++ { go func() { select { case <-ctx.Done(): log.Println("ctx1 done", ctx.Err()) } for i := 0; i < 2; i++ { go func() { select { case <-ctx.Done(): log.Println("ctx2 done", ctx.Err()) } }() } }() } time.Sleep(time.Second*5) log.Println("end", ctx.Err()) fmt.Printf("执行完毕 %v", num) } 在以上例子中，无论 goroutine 嵌套了多少层，都是可以在 context 取消时获得消息（当然前提是 context 得传递走） 某些特殊情况需要提前取消 context 时，也可以手动调用 cancelFunc() 函数。 Gin 中的案例 Gin 提供的 Shutdown(ctx) 函数也充分使用了 context。 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() if err := srv.Shutdown(ctx); err != nil { log.Fatal("Server Shutdown:", err) } log.Println("Server exiting") 比如以上代码便是超时等待 10s 进行 Gin 的资源释放，实现的原理也和上文的例子相同。 总结 因为写 go 的时间不长，所以自己写了一个练手的项目：一个接口压力测试工具。 其中一个很常见的需求就是压测 N 秒后退出，这里正好就应用到了相关知识点，同样是初学 go 的小伙伴可以参考。 https://github.com/crossoverJie/ptg/blob/d0781fcb5551281cf6d90a86b70130149e1525a6/duration.go 到此这篇关于Go语言 里的超时控制的文章就介绍到这了,更多相关Go 超时控制内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

GO 语言的 for…range  能做什么呢？ for…range  如何使用 ? for…range  的返回值有哪些情况，可以对于任何数据结构使用吗？ for…range  的返回值如果不需要，可以如何处理？ for…range  的数据是如何传递的？ 刚学习 golang 的 xdm 会不会有上面的疑问？其实很简单，我们就一个一个的来分享和实操一遍 GO 语言的 for…range  能做什么呢？ golang 的 for…range   是 go 自身的语法，可以用来遍历数据结构，有如下数据结构可以遍历 切片 slice 数组 array map 哈希表 channel 通道 for…range  如何使用 ? 我们分别来看看可以如何使用他们，for…range  相当于一个迭代器，可以遍历数据结构的键/索引 和值 数组 array 初始化一个数组 使用 for…range 遍历 ， 对应的是 索引  和 值 func main() { myArray := [5]int{1, 2, 3, 4, 5} for i, v := range myArray { fmt.Printf("%d -- %d -- %p\n", i, v, &v) } } 切片 slice 初始化一个切片 使用 for…range 遍历 ， 对应的是 索引  和 值 mySlice := []int{1, 2, 3, 4, 5} for i, v := range mySlice { fmt.Printf("%d -- %d -- %p\n", i, v, &v) } map 哈希表 初始化一个 map 哈希表 使用 for…range 遍历 ， map 对应的 键值对 myMap := map[string]string{ "name": "xmt", "hobby": "program", "addr": "mengli", } for k, v := range myMap { fmt.Printf("%s -- %s -- %p\n", k, v, &v) } channel 通道 创建一个可以缓冲 10 个 int 类型数据的通道 创建一个协程专门向通道中写入数据 主协程遍历通道，读取数据 package main import "fmt" var myCh = make(chan int, 10) func writeCh() { for i := 0; i < 5; i++ { myCh <- i } close(myCh) } func main() { go writeCh() for { for data := range myCh { fmt.Println(data) } break } } for…range  的返回值有哪些情况，可以对于任何数据结构使用吗？ 并不是所有数据结构都可以使用  for…range  的，如下结构可以使用这个方法 返回值 1 返回值 2 数据传递 字符串 索引 索引对应的值 值传递 数组或者切片 索引 索引对应的值 数组：值传递 切片：引用传递 哈希表 键 键对应的值 指针 通道 通道中的数据 指针 for…range  的返回值如果不需要，可以如何处理？ 相信写过 golang 的 xdm 都知道，go 里面对于我们不需要的返回值，都可以使用 - 来表示 ，因此 for…range  当然也可以这样 例如： myMap := map[string]string{ "name": "xmt", "hobby": "program", "addr": "mengli", } for _, v := range myMap { fmt.Printf("%s -- %p\n", v, &v) } for…range  的数据是如何传递的？ 数据都是通过复制传递的，也就是都是值传递的，只不过由于数据结构不一样，数组和切片在这里还是有一些区别的 前面的文章，我们有说到，切片，对应着 有 3 个元素的数据结构，一个是 cap，一个是 len， 一个是 ptr ，指向的是一个底层数组 切片是引用传递，但是传递数据的时候，切片这个变量是值传递，但是它实际指向的底层数组还是不会变的 咱们来写一个 demo 查看一下： 我们思路是这个样子： 遍历一个 数组/切片，在遍历当前值的时候，去修改后面索引对应的值，全部遍历完毕后，查看结果中，实际的数据是否会被修改掉，若修改掉了，则是切片是传引用，若没有修改掉，则是数组是传值 数组的效果 myArray := [5]int{1, 2, 3, 4, 5} fmt.Println(myArray) for i, v := range myArray { if i == 0{ myArray[2] = 888 } fmt.Printf("%d -- %d -- %p\n", i, v, &myArray[i]) } 效果如下： go run main.go [1 2 3 4 5] 0 -- 1 -- 0x1189c120 1 -- 2 -- 0x1189c124 2 -- 3 -- 0x1189c128 3 -- 4 -- 0x1189c12c 4 -- 5 -- 0x1189c130 切片的效果 mySlice := []int{1, 2, 3, 4, 5} fmt.Println(mySlice) for i, v := range mySlice { if i == 0{ mySlice[2] = 888 } fmt.Printf("%d -- %d -- %p\n", i, v, &mySlice[i]) } 效果如下： go run main.go [1 2 3 4 5] 0 -- 1 -- 0x1140e340 1 -- 2 -- 0x1140e344 2 -- 888 -- 0x1140e348 3 -- 4 -- 0x1140e34c 4 -- 5 -- 0x1140e350 通过上述的案例，相信心里都有点谱了吧 到此这篇关于Go语言的range具体使用的文章就介绍到这了,更多相关GO range内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文