1. 什么是闭包? 一个函数内引用了外部的局部变量，这种现象，就称之为闭包。 例如下面的这段代码中，adder 函数返回了一个匿名函数，而该匿名函数中引用了 adder 函数中的局部变量 sum ，那这个函数就是一个闭包。 package main import "fmt" func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } 而这个闭包中引用的外部局部变量并不会随着 adder 函数的返回而被从栈上销毁。 我们尝试着调用这个函数，发现每一次调用，sum 的值都会保留在 闭包函数中以待使用。 func main() { valueFunc:= adder() fmt.Println(valueFunc(2)) // output: 2 fmt.Println(valueFunc(2)) // output: 4 } 2. 复杂的闭包场景 写一个闭包是比较容易的事，但单单会写简单的闭包函数，还远远不够，如果不搞清楚闭包真正的原理，那很容易在一些复杂的闭包场景中对函数的执行逻辑进行误判。 别的不说，就拿下来这个例子来说吧? 你觉得它会打印什么呢? 是 6 还是 11 呢? import "fmt" func func1() (i int) { i = 10 defer func() { i += 1 }() return 5 } func main() { closure := func1() fmt.Println(closure) } 3. 闭包的底层原理? 还是以最上面的例子来分析 package main import "fmt" func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } func main() { valueFunc:= adder() fmt.Println(valueFunc(2)) // output: 2 } 我们先对它进行逃逸分析，很容易发现 sum 作为 adder 函数局部变量，并不是分配在栈上，而是分配在堆上的。 这就解决了第一个疑惑：为什么 adder 函数返回后， sum 不会随之销毁? $ go build -gcflags="-m -m -l" demo.go # command-line-arguments ./demo.go:8:3: adder.func1 capturing by ref: sum (addr=true assign=true width=8) ./demo.go:7:9: func literal escapes to heap: ./demo.go:7:9: flow: ~r0 = &{storage for func literal}: ./demo.go:7:9: from func literal (spill) at ./demo.go:7:9 ./demo.go:7:9: from return func literal (return) at ./demo.go:7:2 ./demo.go:6:2: sum escapes to heap: ./demo.go:6:2: flow: {storage for func literal} = &sum: ./demo.go:6:2: from func literal (captured by a closure) at ./demo.go:7:9 ./demo.go:6:2: from sum (reference) at ./demo.go:8:3 ./demo.go:6:2: moved to heap: sum ./demo.go:7:9: func literal escapes to heap ./demo.go:15:23: valueFunc(2) escapes to heap: ./demo.go:15:23: flow: {storage for ... argument} = &{storage for valueFunc(2)}: ./demo.go:15:23: from valueFunc(2) (spill) at ./demo.go:15:23 ./demo.go:15:23: flow: {heap} = {storage for ... argument}: ./demo.go:15:23: from ... argument (spill) at ./demo.go:15:13 ./demo.go:15:23: from fmt.Println(valueFunc(2)) (call parameter) at ./demo.go:15:13 ./demo.go:15:13: ... argument does not escape ./demo.go:15:23: valueFunc(2) escapes to heap 可另一个问题，又浮现出来了，就算它不会销毁，那闭包函数若是存储的若是 sum 拷贝后的值，那每次调用闭包函数，里面的 sum 应该都是一样的，调用两次都应该返回 2，而不是可以累加记录。 因此，可以大胆猜测，闭包函数的结构体里存储的是 sum 的指针。 为了验证这一猜想，只能上汇编了。 通过执行下面的命令，可以输出对应的汇编代码 go build -gcflags="-S" demo.go 输出的内容相当之多，我提取出下面最关键的一行代码，它定义了闭包函数的结构体。 其中 F 是函数的指针，但这不是重点，重点是 sum 存储的确实是指针，验证了我们的猜。 type.noalg.struct { F uintptr; "".sum *int }(SB), CX 4. 迷题揭晓 有了上面第三节的背景知识，那对于第二节给出的这道题，想必你也有答案了。 首先，由于 i 在函数定义的返回值上声明，因此根据 go 的 caller-save 模式， i 变量会存储在 main 函数的栈空间。 然后，func1 的 return 重新把 5 赋值给了 i ，此时 i = 5 由于闭包函数存储了这个变量 i 的指针。 因此最后，在 defer 中对 i 进行自增，是直接更新到 i 的指针上，此时 i = 5+1，所以最终打印出来的结果是 6 import "fmt" func func1() (i int) { i = 10 defer func() { i += 1 }() return 5 } func main() { closure := func1() fmt.Println(closure) } 5. 再度变题 上面那题听懂了的话，再来看看下面这道题。 func1 的返回值我们不写变量名 i 了，然后原先返回具体字面量，现在改成变量 i ，就是这两小小小的改动，会导致运行结果大大不同，你可以思考一下结果。 import "fmt" func func1() (int) { i := 10 defer func() { i += 1 }() return i } func main() { closure := func1() fmt.Println(closure) } 如果你在返回值里写了变量名，那么该变量会存储 main 的栈空间里，而如果你不写，那 i 只能存储在 func1 的栈空间里，与此同时，return 的值，不会作用于原变量 i 上，而是会存储在该函数在另一块栈内存里。 因此你在 defer 中对原 i 进行自增，并不会作用到 func1 的返回值上。 所以打印的结果，只能是 10。 你答对了吗? 6. 最后一个问题 不知道你有没有发现，在第一节示例中的 sum 是存储在堆内存中的，而后面几个示例都是存储在栈内存里。 这是为什么呢? 仔细对比，不难发现，示例一返回的是闭包函数，闭包函数在 adder 返回后还要在其他地方继续使用，在这种情况下，为了保证闭包函数的正常运行，无论闭包函数在哪里，i 都不能回收，所以 Go 编译器会智能地将其分配在堆上。 而后面的其他示例，都只是涉及了闭包的特性，并不是直接把闭包函数返回，因此完全可以将其分配在栈上，非常的合理。 到此这篇关于Go语言 中闭包的底层原理的文章就介绍到这了,更多相关Go 闭包底层原理内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

学习 Go 语言的开发者越来越多了，很多小伙伴在使用时，就会遇到种种不理解的问题。 其中一点就是包的循环引用的报错： packagecommand-line-arguments imports github.com/eddycjy/awesome-project/a imports github.com/eddycjy/awesome-project/b imports github.com/eddycjy/awesome-project/a: import cycle not allowed 一下子就很懵逼了，为什么 Go 不支持包之间的循环引用呢，这就很不解了，难道还影响性能了？ 如下图： 今天煎鱼将和大家一起了解背后的原因。 1、案例演示 这里我们做一个基本的案例 Demo，便于没接触过的同学建立初步认知。我们的程序分别有 2 个 package。 package a 的代码如下： import ( "github.com/eddycjy/awesome-project/b" ) func Hello(s string) { b.Print(s) } package b 的代码如下： import ( "fmt" "github.com/eddycjy/awesome-project/a" ) func Hello() { a.Hello("脑子进煎鱼了") } func Print(s string) { fmt.Println(s) } 再在 main.go 的文件中调用 a.Hello("脑子进煎鱼了") 方法。 一运行，就会出现如下错误提示： package command-line-arguments  imports github.com/eddycjy/awesome-project/a  imports github.com/eddycjy/awesome-project/b  imports github.com/eddycjy/awesome-project/a: import cycle not allowed 错误的本质原因是 package a 引用了 package b，而 package b 又引用了 package a，造成了循环引用。 这在 Go 语言中是明令禁止的，在编译时就会中断程序，导致编译失败。 2、原因分析 根据现在 Go 官方的统一意见来看，package 循环导入几乎不可能出现，即使是 Go2，也被明确拒绝了。 因为 Go2 可能是很多核心问题的破变的关键节点，有许多人提了类似《proposal: Go 2: allow import cycle》的提案，希望解决循环引入的问题。 Go 语言之父 Rob Pike 亲自回答了这个问题，原因如下： 没有支持循环引用：目的是迫使 Go 程序员更多地考虑程序的依赖关系。 保持依赖关系图的简洁。 快速的程序构建。 如果支持循环引用：很容易会造成懒惰、不良的依赖性管理和缓慢的构建。这是设计者不希望看见的。 混乱的依赖关系。 缓慢的程序构建 因此考虑一开始就保持依赖图的正确 DAG，Rob Pike 认为这是一个值得预先简化的领域。 在 Go 程序中去做导入循环这件事可能很方便，但背后的代价可能是灾难性的，会对 Go 的构建性能和依赖关系造成非常不利的影响。 所以在 Go 中被明确禁止支持。 3、总结 在程序中，如果我们频繁的出现模块与模块之间的循环引用，这时候我们是不是应该考虑一下，是不是设计的有些问题，要不要考虑调整？ 但也并非所有的事都是二极管，Go 源码可能或多或少都有自己循环引用的案例，最重要的是想清楚。 到此这篇关于为什么Go语言不支持循环引用的文章就介绍到这了,更多相关GO不支持循环引用内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

redigo 对 发布订阅的使用 redigo 对redis 的发布订阅机制放在pubsub.go 中 订阅主题后 通过Receive()函数接受发布订阅主题的消息 // Receive returns a pushed message as a Subscription, Message, Pong or error. // The return value is intended to be used directly in a type switch as // illustrated in the PubSubConn example. func (c PubSubConn) Receive() interface{} { return c.receiveInternal(c.Conn.Receive()) } 返回的是一个空类型的interface{} , 由于空接口没有方法， 因此所有的类型都实现了空接口， 也就是说可以返回任意类型。 具体返回的类型 在receiveInternal（） 方法里面可以看到 func (c PubSubConn) receiveInternal(replyArg interface{}, errArg error) interface{} { reply, err := Values(replyArg, errArg) if err != nil { return err } var kind string reply, err = Scan(reply, &kind) if err != nil { return err } switch kind { case "message": var m Message if _, err := Scan(reply, &m.Channel, &m.Data); err != nil { return err } return m case "pmessage": var m Message if _, err := Scan(reply, &m.Pattern, &m.Channel, &m.Data); err != nil { return err } return m case "subscribe", "psubscribe", "unsubscribe", "punsubscribe": s := Subscription{Kind: kind} if _, err := Scan(reply, &s.Channel, &s.Count); err != nil { return err } return s case "pong": var p Pong if _, err := Scan(reply, &p.Data); err != nil { return err } return p } return errors.New("redigo: unknown pubsub notification") } 目前返回 Message Subscription Pone 订阅的主题 收到消息之后通过注册的回调函数处理的方式， 所以代码中多了长map存放回调函数 package main import ( //"github.com/go-redis/redis" "fmt" "github.com/labstack/gommon/log" "github.com/gomodule/redigo/redis" "time" //"reflect" "unsafe" ) type SubscribeCallback func (channel, message string) type Subscriber struct { client redis.PubSubConn cbMap map[string]SubscribeCallback } func (c *Subscriber) Connect(ip string, port uint16) { conn, err := redis.Dial("tcp", "127.0.0.1:6379") if err != nil { log.Error("redis dial failed.") } c.client = redis.PubSubConn{conn} c.cbMap = make(map[string]SubscribeCallback) go func() { for { log.Info("wait...") switch res := c.client.Receive().(type) { case redis.Message: channel := (*string)(unsafe.Pointer(&res.Channel)) message := (*string)(unsafe.Pointer(&res.Data)) c.cbMap[*channel](*channel, *message) case redis.Subscription: fmt.Printf("%s: %s %d\n", res.Channel, res.Kind, res.Count) case error: log.Error("error handle...") continue } } }() } func (c *Subscriber) Close() { err := c.client.Close() if err != nil{ log.Error("redis close error.") } } func (c *Subscriber) Subscribe(channel interface{}, cb SubscribeCallback) { err := c.client.Subscribe(channel) if err != nil{ log.Error("redis Subscribe error.") } c.cbMap[channel.(string)] = cb } func TestCallback1(chann, msg string){ log.Info("TestCallback1 channel : ", chann, " message : ", msg) } func TestCallback2(chann, msg string){ log.Info("TestCallback2 channel : ", chann, " message : ", msg) } func TestCallback3(chann, msg string){ log.Info("TestCallback3 channel : ", chann, " message : ", msg) } func main() { log.Info("===========main start============") var sub Subscriber sub.Connect("127.0.0.1", 6397) sub.Subscribe("test_chan1", TestCallback1) sub.Subscribe("test_chan2", TestCallback2) sub.Subscribe("test_chan3", TestCallback3) for{ // 这段代码的作用就是 阻止线程结束 time.Sleep(1 * time.Second) } } 运行main 文件 然后 看到 在redis 客户端 执行 发布信息 在控制台 看到监控结果 回调函数 执行的结果 发布 上面是订阅的代码和 代码要处理 的回调函数 发布直接使用默认的 Conn来Send Publish 就可以 redigo 的管道使用方法设计到三个函数 Do 函数也是下面这个函数的合并 c.Send() c.Flush() c.Receive() 解释： send() 方法吧命令写到缓冲区， flush() 把缓冲区的命令刷新到redis 服务器 receive() 函数接受redis 给予的 回应， 三个操作共同完成一套命令流程。 代码 package main import( //"github.com/go-redis/redis" "github.com/gomodule/redigo/redis" log "github.com/astaxie/beego/logs" ) func main() { client, err := redis.Dial("tcp", "127.0.0.1:6379") if err != nil { log.Critical("redis dial failed.") } defer client.Close() _, err = client.Do("Publish", "test_chan1", "hello") if err != nil { log.Critical("redis Publish failed.") } _, err = client.Do("Publish", "test_chan2", "hello") if err != nil { log.Critical("redis Publish failed.") } _, err = client.Do("Publish", "test_chan3", "hello") if err != nil { log.Critical("redis Publish failed.") } } 到此这篇关于golang redigo发布订阅使用的方法的文章就介绍到这了,更多相关Go语言 redigo发布订阅内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

Go 是一门带 GC 的语言，因此，大家很容易认为它不会有内存泄露问题。 大部分时候确实不会，但如果有些时候使用不注意，也会导致泄露。 本文案例来自谷歌云的代码，探讨如何找到并修复 Go 中的内存泄露。（确切来说是因为资源泄露导致的内存泄露，除了本文介绍的，还有一些其他泄露的情况） 这篇文章回顾了我如何发现内存泄漏、如何修复它，以及我如何修复 Google 示例 Go 代码中的类似问题，以及我们如何改进我们的库以防止将来发生这种情况。 Google Cloud Go 客户端库 [1] 通常在后台使用 gRPC 来连接 Google Cloud API。创建 API 客户端时，库会初始化与 API 的连接，然后保持该连接处于打开状态，直到你调用 Client.Close 。 client, err := api.NewClient() // Check err. defer client.Close() 客户端可以安全地同时使用，所以你应该保持相同 Client 直到你的任务完成。但是，如果在应该 Close 的时候不 Close client 会发生什么呢？ 会出现内存泄漏。底层连接永远不会被清理。 Google 有一堆 GitHub 自动化机器人来帮助管理数百个 GitHub 存储库。我们的一些机器人通过在 Cloud Run [2] 上运行的 Go 服务器 [3] 代理它们的请求。我们的内存使用看起来像一个经典的锯齿形内存泄漏： 我通过向服务器添加 pprof.Index 处理程序开始调试： mux.HandleFunc("/debug/pprof/", pprof.Index) `pprof` [4] 提供运行时 profiling 数据，如内存使用情况。有关更多信息，请参阅 Go 官方博客上的 profiling Go 程序 [5] 。 然后，我在本地构建并启动了服务器： $ go build $ PROJECT_ID=my-project PORT=8080 ./serverless-scheduler-proxy 然后向服务器发送一些请求： for i in {1..5}; do curl --header "Content-Type: application/json" --request POST --data '{"name": "HelloHTTP", "type": "testing", "location": "us-central1"}' localhost:8080/v0/cron echo " -- $i" done 确切的有效负载和端点特定于我们的服务器，与本文无关。 为了获得正在使用的内存的基线，我收集了一些初始 pprof 数据： curl http://localhost:8080/debug/pprof/heap > heap.0.pprof 检查输出，你可以看到一些内存使用情况，但没有什么会立即成为一个大问题（这很好！我们刚刚启动了服务器！）： $ go tool pprof heap.0.pprof File: serverless-scheduler-proxy Type: inuse_space Time: May 4, 2021 at 9:33am (EDT) Entering interactive mode (type "help" for commands, "o" for options) (pprof) top10 Showing nodes accounting for 2129.67kB, 100% of 2129.67kB total Showing top 10 nodes out of 30 flat flat% sum% cum cum% 1089.33kB 51.15% 51.15% 1089.33kB 51.15% google.golang.org/grpc/internal/transport.newBufWriter (inline) 528.17kB 24.80% 75.95% 528.17kB 24.80% bufio.NewReaderSize (inline) 512.17kB 24.05% 100% 512.17kB 24.05% google.golang.org/grpc/metadata.Join 0 0% 100% 512.17kB 24.05% cloud.google.com/go/secretmanager/apiv1.(*Client).AccessSecretVersion 0 0% 100% 512.17kB 24.05% cloud.google.com/go/secretmanager/apiv1.(*Client).AccessSecretVersion.func1 0 0% 100% 512.17kB 24.05% github.com/googleapis/gax-go/v2.Invoke 0 0% 100% 512.17kB 24.05% github.com/googleapis/gax-go/v2.invoke 0 0% 100% 512.17kB 24.05% google.golang.org/genproto/googleapis/cloud/secretmanager/v1.(*secretManagerServiceClient).AccessSecretVersion 0 0% 100% 512.17kB 24.05% google.golang.org/grpc.(*ClientConn).Invoke 0 0% 100% 1617.50kB 75.95% google.golang.org/grpc.(*addrConn).createTransport 下一步是向服务器发送一堆请求，看看我们是否可以 (1) 重现可能的内存泄漏和 (2) 确定泄漏是什么。 发送 500 个请求： for i in {1..500}; do curl --header "Content-Type: application/json" --request POST --data '{"name": "HelloHTTP", "type": "testing", "location": "us-central1"}' localhost:8080/v0/cron echo " -- $i" done 收集和分析更多 pprof 数据： $ curl http://localhost:8080/debug/pprof/heap > heap.6.pprof $ go tool pprof heap.6.pprof File: serverless-scheduler-proxy Type: inuse_space Time: May 4, 2021 at 9:50am (EDT) Entering interactive mode (type "help" for commands, "o" for options) (pprof) top10 Showing nodes accounting for 94.74MB, 94.49% of 100.26MB total Dropped 26 nodes (cum <= 0.50MB) Showing top 10 nodes out of 101 flat flat% sum% cum cum% 51.59MB 51.46% 51.46% 51.59MB 51.46% google.golang.org/grpc/internal/transport.newBufWriter 19.60MB 19.55% 71.01% 19.60MB 19.55% bufio.NewReaderSize 6.02MB 6.01% 77.02% 6.02MB 6.01% bytes.makeSlice 4.51MB 4.50% 81.52% 10.53MB 10.51% crypto/tls.(*Conn).readHandshake 4MB 3.99% 85.51% 4.50MB 4.49% crypto/x509.parseCertificate 3MB 2.99% 88.51% 3MB 2.99% crypto/tls.Client 2.50MB 2.49% 91.00% 2.50MB 2.49% golang.org/x/net/http2/hpack.(*headerFieldTable).addEntry 1.50MB 1.50% 92.50% 1.50MB 1.50% google.golang.org/grpc/internal/grpcsync.NewEvent 1MB 1% 93.50% 1MB 1% runtime.malg 1MB 1% 94.49% 1MB 1% encoding/json.(*decodeState).literalStore google.golang.org/grpc/internal/transport.newBufWriter 使用大量内存真的很突出！这是泄漏与什么相关的第一个迹象：gRPC。查看我们的应用程序源代码，我们唯一使用 gRPC 的地方是 Google Cloud Secret Manager [6] ： client, err := secretmanager.NewClient(ctx) if err != nil { return nil, fmt.Errorf("failed to create secretmanager client: %v", err) } 在每个请求创建 client 时，我们没有调用 client.Close() ！所以，我添加了一个 Close 调用，问题就消失了： defer client.Close() 我提交了修复，然后 自动部署 [7] ，锯齿立即消失了！ 大约在同一时间，用户在我们的 Cloud 的 Go 示例存储库中 [8] 提交了一个问题，其中包含 cloud.google.com 上 [9] 文档的大部分 Go 示例。用户注意到我们忘记调用 client.Close 了。 我曾多次看到同样的事情出现，所以我决定调查整个 repo。 我开始粗略估计有多少受影响的文件。使用 grep ，我们可以获得包含 NewClient 样式调用的所有文件的列表，然后将该列表传递给另一个调用 grep 以仅列出不包含 Close 的文件，同时忽略测试文件： $ grep -L Close $(grep -El 'New[^(]*Client' **/*.go) | grep -v test 竟然有 207 个文件……就上下文而言，我们 .go 在 GoogleCloudPlatform/golang-samples [10] 存储库中有大约 1300 个文件。 考虑到问题的规模，我认为一些自动化是 值得的 [11] 。我不想写一个完整的 Go 程序来编辑文件，所以我使用 Bash： $ grep -L Close $(grep -El 'New[^(]*Client' **/*.go) | grep -v test | xargs sed -i '/New[^(]*Client/,/}/s/}/}\ndefer client.Close()/' 它是完美的吗？不。它对工作量有很大的影响吗？是的！ 第一部分（直到 test ）与上面完全相同——获取所有可能受影响的文件的列表（那些似乎创建了 Client 但从没调用 Close 的文件）。 然后，我将该文件列表传递给 sed 进行实际编辑。 xargs 调用你给它的命令，每一行都以 stdin 作为参数传递给给定的命令。 要理解该 sed 命令，查看 golang-samples repo 示例是什么样子有助于理解（省略导入和客户端初始化后的所有内容）： // accessSecretVersion accesses the payload for the given secret version if one // exists. The version can be a version number as a string (e.g. "5") or an // alias (e.g. "latest"). func accessSecretVersion(w io.Writer, name string) error { // name := "projects/my-project/secrets/my-secret/versions/5" // name := "projects/my-project/secrets/my-secret/versions/latest" // Create the client. ctx := context.Background() client, err := secretmanager.NewClient(ctx) if err != nil { return fmt.Errorf("failed to create secretmanager client: %v", err) } // ... } 在高层次上，我们初始化客户端并检查是否有错误。每当你检查错误时，都会有一个右花括号 ( } )。我使用这些信息来自动化编辑。 但是，该 sed 命令仍然很笨拙： sed -i '/New[^(]*Client/,/}/s/}/}\ndefer client.Close()/' -i 表示直接编辑文件。这不是问题，因为代码用 git 管理了。 接下来，我使用 s 命令在检查错误 defer client.Close() 后假定的右花括号 ( } )之后插入。 但是，我不想替换每个 } ，我只想要在 调用 NewClient 后 的 第一个 。要做到这一点，你可以给一个 地址范围 [12] 的 sed 搜索。 地址范围可以包括在应用接下来的任何命令之前要匹配的开始和结束模式。在这种情况下，开始是 /New[^(]*Client/ ，匹配 NewClient 类型调用，结束（由 a 分隔 , ）是 /}/ ，匹配下一个大括号。这意味着我们的搜索和替换仅适用于调用 NewClient 和结束大括号之间！ 通过了解上面的错误处理模式， if err != nil 条件的右大括号正是我们想要插入 Close 调用的位置。 一旦我自动编辑了所有示例文件，我用 goimports 开始修复格式。然后，我检查了每个编辑过的文件，以确保它做了正确的事情： 在服务器应用程序中，我们应该关闭客户端，还是应该保留它以备将来的请求使用？ 是 Client 实际的名字 client 还是别的什么？ 是否有一个以上的 Client 调用了 Close ？ 完成后，只剩下 180 个已编辑的文件 [13] 。 最后一项工作是努力使其不再发生在用户身上。我们想到了几种方法： 更好的示例代码； 更好的 GoDoc。我们更新了库生成器，在生成库时加上注释，告知 client 需要调用 Close； 更好的库。有没有办法可以自动 Close 客户端？Finalizers？知道何能做得更好吗？欢迎在 https://github.com/googleapis/google-cloud-go/issues/4498 上交流； 我希望你对 Go、内存泄漏 pprof 、gRPC 和 Bash 有所了解。我很想听听你关于发现的内存泄漏以及修复它们的方法的故事！如果你对我们如何改进我们的 库 [14] 或 示例 [15] 有任何想法，请通过提交 issue 告诉我们。 参考资料 [1] Google Cloud Go 客户端库: https://github.com/googleapis/google-cloud-go [2] Cloud Run: https://cloud.google.com/run/docs/quickstarts/build-and-deploy/go [3] Go 服务器: https://github.com/googleapis/repo-automation-bots/tree/main/serverless-scheduler-proxy [4] pprof: https://pkg.go.dev/net/http/pprof [5] profiling Go 程序: https://go.dev/blog/pprof [6] Google Cloud Secret Manager: https://cloud.google.com/secret-manager/docs/quickstart [7] 自动部署: https://cloud.google.com/build/docs/deploying-builds/deploy-cloud-run [8] Cloud 的 Go 示例存储库中: https://github.com/GoogleCloudPlatform/golang-samples [9] cloud.google.com 上: https://cloud.google.com/ [10] GoogleCloudPlatform/golang-samples: https://github.com/GoogleCloudPlatform/golang-samples [11] 值得的: https://xkcd.com/1205/ [12] 地址范围: https://www.gnu.org/software/sed/manual/html_node/Addresses.html [13] 180 个已编辑的文件: https://github.com/GoogleCloudPlatform/golang-samples/pull/2080 [14] 库: https://github.com/googleapis/google-cloud-go [15] 示例: https://github.com/GoogleCloudPlatform/golang-samples 到此这篇关于定位并修复 Go语言 中的内存泄露的文章就介绍到这了,更多相关定位Go内存泄露内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1、互斥锁Mutex 1.1 Mutex介绍 Go 语言的同步工具主要由 sync 包提供，互斥锁 (Mutex) 与读写锁 (RWMutex) 就是sync 包中的方法。 互斥锁可以用来保护一个临界区，保证同一时刻只有一个 goroutine 处于该临界区内。主要包括锁定（Lock方法）和解锁（Unlock方法）两个操作，首先对进入临界区的goroutine进行锁定，离开时进行解锁。 使用互斥锁 (Mutex)时要注意以下几点： 不要重复锁定互斥锁，否则会阻塞，也可能会导致死锁（deadlock）； 要对互斥锁进行解锁，这也是为了避免重复锁定； 不要对未锁定或者已解锁的互斥锁解锁； 不要在多个函数之间直接传递互斥锁，sync.Mutex类型属于值类型，将它传给一个函数时，会产生一个副本，在函数中对锁的操作不会影响原锁 总之，一个互斥锁只用来保护一个临界区，加锁后记得解锁，对于每一个锁定操作，都要有且只有一个对应的解锁操作，也就是加锁和解锁要成对出现，最保险的做法时使用defer语句解锁。 1.2 Mutex使用实例 下面的代码模拟取钱和存钱操作： package main import ( "flag" "fmt" "sync" ) var ( mutex sync.Mutex balance int protecting uint // 是否加锁 sign = make(chan struct{}, 10) //通道，用于等待所有goroutine ) // 存钱 func deposit(value int) { defer func() { sign <- struct{}{} }() if protecting == 1 { mutex.Lock() defer mutex.Unlock() } fmt.Printf("余额: %d\n", balance) balance += value fmt.Printf("存 %d 后的余额: %d\n", value, balance) fmt.Println() } // 取钱 func withdraw(value int) { defer func() { sign <- struct{}{} }() if protecting == 1 { mutex.Lock() defer mutex.Unlock() } fmt.Printf("余额: %d\n", balance) balance -= value fmt.Printf("取 %d 后的余额: %d\n", value, balance) fmt.Println() } func main() { for i:=0; i < 5; i++ { go withdraw(500) // 取500 go deposit(500) // 存500 } for i := 0; i < 10; i++ { <-sign } fmt.Printf("当前余额: %d\n", balance) } func init() { balance = 1000 // 初始账户余额为1000 flag.UintVar(&protecting, "protecting", 0, "是否加锁，0表示不加锁，1表示加锁") } 上面的代码中，使用了通道来让主 goroutine 等待其他 goroutine 运行结束，每个子goroutine在运行结束之前向通道发送一个元素，主 goroutine 在最后从这个通道接收元素，接收次数与子goroutine个数相同。接收完后就会退出主goroutine。 代码使用协程实现多次（5次）对一个账户进行存钱和取钱的操作，先来看不加锁的情况 余额: 1000 存 500 后的余额: 1500 余额: 1000 取 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1000 取 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1000 取 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 1000 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 1000 存 500 后的余额: 1000 当前余额: 1000 可以看到出现了混乱，比如第二次1000的余额取500后还是1000，这种对同一资源的竞争出现了竞态条件(Race Condition)。 下面来看加锁的执行结果： 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1500 取 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 当前余额: 1000 加锁后就正常了。 下面介绍更细化的互斥锁：读/写互斥锁RWMutex。 2、读写锁RWMutex 2.1 RWMutex介绍 读/写互斥锁RWMutex包含了读锁和写锁，分别对共享资源的“读操作”和“写操作”进行保护。sync.RWMutex类型中的Lock方法和Unlock方法分别用于对写锁进行锁定和解锁，而它的RLock方法和RUnlock方法则分别用于对读锁进行锁定和解锁。 有了互斥锁Mutex，为什么还需要读写锁呢？因为在很多并发操作中，并发读取占比很大，写操作相对较少，读写锁可以并发读取，这样可以提供服务性能。读写锁具有以下特征： 读写锁 读锁 写锁 读锁 Yes No 写锁 No No 也就是说： 如果某个共享资源受到读锁和写锁保护时，其它goroutine不能进行写操作。换句话说就是读写操作和写写操作不能并行执行，也就是读写互斥； 受读锁保护时，可以同时进行多个读操作。 在使用读写锁时，还需要注意： 不要对未锁定的读写锁解锁； 对读锁不能使用写锁解锁 对写锁不能使用读锁解锁 2.2 RWMutex使用实例 改写前面的取钱和存钱操作，添加查询余额的方法： package main import ( "fmt" "sync" ) // account 代表计数器。 type account struct { num uint // 操作次数 balance int // 余额 rwMu *sync.RWMutex // 读写锁 } var sign = make(chan struct{}, 15) //通道，用于等待所有goroutine // 查看余额：使用读锁 func (c *account) check() { defer func() { sign <- struct{}{} }() c.rwMu.RLock() defer c.rwMu.RUnlock() fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance) } // 存钱：写锁 func (c *account) deposit(value int) { defer func() { sign <- struct{}{} }() c.rwMu.Lock() defer c.rwMu.Unlock() fmt.Printf("余额: %d\n", c.balance) c.num += 1 c.balance += value fmt.Printf("存 %d 后的余额: %d\n", value, c.balance) fmt.Println() } // 取钱：写锁 func (c *account) withdraw(value int) { defer func() { sign <- struct{}{} }() c.rwMu.Lock() defer c.rwMu.Unlock() fmt.Printf("余额: %d\n", c.balance) c.num += 1 c.balance -= value fmt.Printf("取 %d 后的余额: %d\n", value, c.balance) fmt.Println() } func main() { c := account{0, 1000, new(sync.RWMutex)} for i:=0; i < 5; i++ { go c.withdraw(500) // 取500 go c.deposit(500) // 存500 go c.check() } for i := 0; i < 15; i++ { <-sign } fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance) } 执行结果： 余额: 1000 取 500 后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 1 次操作后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 存 500 后的余额: 1500 余额: 1500 取 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 余额: 1000 取 500 后的余额: 500 余额: 500 存 500 后的余额: 1000 10 次操作后的余额: 1000 读写锁和互斥锁的不同之处在于读写锁把对共享资源的读操作和写操作分开了，可以实现更复杂的访问控制。 总结： 读写锁也是一种互斥锁，它是互斥锁的扩展。在使用时需要注意： 加锁后一定要解锁 不要重复加锁或者解锁 不解锁未锁定的锁 不要传递互斥锁 到此这篇关于Go语言并发编程 互斥锁详情的文章就介绍到这了,更多相关Go语言语言并发编程 互斥锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

xdm，我们都知道 golang 是天生的高并发，高效的编译型语言 可我们也都可知道，工具再好，用法不对，全都白费，我们来举 2 个常用路径来感受一下 struct 和 map 用谁呢？ 计算量很小的时候，可能看不出使用 临时 struct 和 map 的耗时差距，但是数量起来了，差距就明显了，且会随着数量越大，差距越发明显 当我们遇到键和值都可以是固定的时候，我们选择 struct 比 选择 map 的方式 高效多了 我们模拟循环计算 1 亿 次，看看使用各自的数据结构会耗时多少 循环前计算一下当前时间 循环后计算一下当前时间 最后计算两个时间的差值，此处我们使用 毫秒为单位 func main() { t1 :=time.Now().UnixNano()/1e6 for i := 0; i < 100000000; i++ { var test struct { Name string hobby string } test.Name = "xiaomotong" test.hobby = "program" } t2 :=time.Now().UnixNano()/1e6 fmt.Println("t2 - t1 == ", t2-t1) } 程序运行查看效果： # go run main.go t1 ==  1634377149185 t2 ==  1634377149221 t2 - t1 ==  36 使用 struct 的方式，耗时 36 ms ，大家感觉这个时间如何？ 我们一起来看看使用 map 的方式吧 func main() { t1 :=time.Now().UnixNano()/1e6 fmt.Println("t1 == ", t1) for i := 0; i < 100000000; i++ { var test = map[string]interface{}{} test["name"] = "xiaomotong" test["hobby"] = "program" } t2 :=time.Now().UnixNano()/1e6 fmt.Println("t2 == ", t2) fmt.Println("t2 - t1 == ", t2-t1) } 程序运行查看效果： # go run main.go t1 ==  1634377365927 t2 ==  1634377373525 t2 - t1 ==  7598 使用 struct 的方式，耗时 7598 ms 使用 map 和 使用 struct 的方式，完成同样数据处理，耗时相差 212 倍 ， 就这，我们平时编码的时候，对于上述的场景，你会选择哪种数据结构呢？ 为什么上述差距会那么大，原因是 在我们可以确定字段的情况下，我们使用 临时的 Struct 在运行期间是不需要动态分配内容的， 可是 map 就不一样，map 还要去检查索引，这一点就非常耗时了 字符串如何拼接是好？ 工作中编码 xdm 遇到字符串拼接的情况，都是如何实现的呢？我们的工具暂时提供如下几种： 使用 + 的方式 使用 fmt.Sprintf() 的方式 使用 strings.Join 的方式 使用 buffer 的方式 看到这里，也许我们各有各的答案，不过我们还是来实操一遍，看看他们在相同字符串拼接情况下，各自的处理耗时如何 用 + 的方式 我们来计算循环追加 50 万 次字符串，看看耗时多少 func main() { t1 := time.Now().UnixNano() / 1e6 fmt.Println("t1 == ", t1) s := "xiao" for i := 0; i < 500000; i++ { s += "motong" } t2 := time.Now().UnixNano() / 1e6 fmt.Println("t2 == ", t2) fmt.Println("t2 - t1 == ", t2-t1) } 程序运行查看效果： # go run main.go t1 ==  1634378595642 t2 ==  1634378743119 t2 - t1 ==  147477 看到这个数据 xdm 有没有惊呆了，居然这么慢，耗时 147477 ms 那可是妥妥的 2分27秒呀 Go语言 中使用+处理字符串是很消耗性能的，通过数据我们就可以看出来 使用 fmt.Sprintf() 的方式 func main() { t1 := time.Now().UnixNano() / 1e6 fmt.Println("t1 == ", t1) s := "xiao" for i := 0; i < 500000; i++ { s = fmt.Sprintf("%s%s",s,"motong") } t2 := time.Now().UnixNano() / 1e6 fmt.Println("t2 == ", t2) fmt.Println("t2 - t1 == ", t2-t1) } 程序运行查看效果： # go run main.go t1 ==  1634378977361 t2 ==  1634379240292 t2 - t1 ==  262931 看到这个数据，咱们也惊呆了，居然耗时 262931 ms，合计 4 分 22秒 ，xdm 是不是没有想到 使用 fmt.Sprintf 比 使用 + 还慢 使用 strings.Join 的方式 func main() { t1 := time.Now().UnixNano() / 1e6 fmt.Println("t1 == ", t1) s := "xiao" for i := 0; i < 500000; i++ { s = strings.Join([]string{s,"motong"},"") } t2 := time.Now().UnixNano() / 1e6 fmt.Println("t2 == ", t2) fmt.Println("t2 - t1 == ", t2-t1) } 程序运行查看效果： # go run main.go t1 ==  1634379455304 t2 ==  1634379598227 t2 - t1 ==  142923 耗时 142923 ms ，合计 2 分 22秒 ，和 使用 +的方式不相上下 使用 buffer 的方式 使用 buffer 的方式 应该说是最好的方式， func main() { t1 := time.Now().UnixNano() / 1e6 fmt.Println("t1 == ", t1) s := bytes.NewBufferString("xiao") for i := 0; i < 500000; i++ { s.WriteString("motong") } t2 := time.Now().UnixNano() / 1e6 fmt.Println("t2 == ", t2) fmt.Println("t2 - t1 == ", t2-t1) } # go run main.go t1 == 1634378506021 t2 == 1634378506030 t2 - t1 == 9 通过上面的数据，我们看到，拼接同样 50 万次的数据 第一种，使用 + 的方式 ，需要 147477 ms 第二种，使用 fmt.Sprintf() 的方式，需要 262931 ms 第三种，使用 strings.Join 的方式，需要 142923 ms 第四种，使用 buffer 的方式 ，需要 9ms 使用 buffer 的方式 是 第一种的 16,386 倍 ，是第二种的 29,214 倍 ，是第三种的 15,880 倍 xdm ，如果是遇到上面的场景，你会选择使用哪一种方式呢 到此这篇关于浅谈golang 的高效编码细节的文章就介绍到这了,更多相关Go语言 高效编码内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1、命令行工具概述 日常命令行操作，相对应的众多命令行工具是提高生产力的必备工具，鼠标能够让用户更容易上手，降低用户学习成本。 而对于开发者，键盘操作模式能显著提升生产力，还有在一些专业工具中， 大量使用快捷键代替繁琐的鼠标操作，能够使开发人员更加专注于工作，提高效率，因为键盘操作模式更容易产生肌肉记忆 举个栗子：我司业务研发，前些年在我们的强力推动下（被迫）转向使用了 git 作为版本控制，开始使用的是图形化“小乌龟”工具。后续出现几次问题解决起来较麻烦后，推荐其使用原生的 git 命令行。如今，使用 git 命令行操作版本控制可谓 “一顿操作猛如虎......” 命令行（键盘）操作在很大程度上可以提高工作效率，与之相对应的是鼠标（触屏等）操作，这两种模式是目前的主流人机交互方式 设计一款命令行工具的开发语言可以选择原始的 shell 、甚至是更原始的语言 C ，更为容易上手且功能更多的有 node 、 python 、 golang 本文是基于 golang 开发命令行工具的开篇，主要是基于 golang 原生内置的、轻量的 flag 包实现，用 golang 设计命令行工具而不用 shell 、 python 的原因这里就不做论述了 2、flag包介绍 flag 包用来解析命令行参数 相比简单的使用 os.Args 来获取命令行参数， flag 可以实现按照更为通用的命令行用法，例如 mysql -u root -p 123456 。其中 mysql 是命令行的名称即这个命令， -u 和 -p 分别是这个命令的两个参数：用户名和密码，后面接着的是对应的参数值，有了参数的声明之后，两个参数可以互换位置，参数值也可以选填或按照缺省(默认)值进行指定 flag 包支持的命令行参数的类型有 bool 、 int 、 int64 、 uint 、 uint64 、 float float64 、 string 、 duration 即布尔值、整型、浮点型、字符串、时间段类型 3、flag包命令行参数的定义 定义 flag 命令行参数，用来接收命令行输入的参数值，一般有以下两种方法 flag.TypeVar()：先定义参数（实际上是指针），再定义 flag.TypeVar 将命令行参数存储(绑定)到前面参数的值的指针(地址) var name string var age int var height float64 var graduated bool // &name 就是接收用户命令行中输入的-n后面的参数值 // 返回值是一个用来存储name参数的值的指针/地址 // 定义string类型命令行参数name，括号中依次是变量名、flag参数名、默认值、参数说明 flag.StringVar(&name, "n", "", "name参数,默认为空") // 定义整型命令行参数age flag.IntVar(&age,"a", 0, "age参数,默认为0") // 定义浮点型命令行参数height flag.Float64Var(&height,"h", 0, "height参数,默认为0") // 定义布尔型命令行参数graduated flag.BoolVar(&graduated,"g", false, "graduated参数,默认为false") flag.Type()：用短变量声明的方式定义参数类型及变量名 // 定义string类型命令行参数name，括号中依次是flag参数名、默认值、参数说明 namePtr := flag.String("n", "", "name参数,默认为空") // 定义整型命令行参数age age := flag.Int("a", 0, "age参数,默认为0") // 定义浮点型命令行参数height height := flag.Float64("h", 0, "height参数,默认为0") // 定义布尔型命令行参数graduated graduated:= flag.Bool("g", false, "graduated参数,默认为false") 4、flag包命令行参数解析 固定用法，定义好参数后，通过调用 flag.Parse() 来对命令行参数进行解析写入注册的 flag 里，进而解析获取参数值，通过查看源码中也是调用的 os.Args 源码路径 go/src/flag/flag.go // Parse parses the command-line flags from os.Args[1:]. Must be called // after all flags are defined and before flags are accessed by the program. func Parse() { // Ignore errors; CommandLine is set for ExitOnError. CommandLine.Parse(os.Args[1:]) } 进而查看 Parse 方法的源码 func (f *FlagSet) Parse(arguments []string) error { f.parsed = true f.args = arguments for { seen, err := f.parseOne() if seen { continue } if err == nil { break } switch f.errorHandling { case ContinueOnError: return err case ExitOnError: if err == ErrHelp { os.Exit(0) } os.Exit(2) case PanicOnError: panic(err) } } return nil } 真正解析参数的是 parseOne 方法（这里省略源码），结论是 当遇到单独的一个 "-" 或不是 "-" 开始时，会停止解析 遇到连续的两个 "-" 时，解析停止 在终止符"-"之后停止 解析参数时，对于参数的指定方式一般有"-"、"--"、以及是否空格等方式，组合下来有如下几种方式 -flag xxx 空格和一个 - 符号 --flag xxx 空格和两个 - 符号 -flag=xxx 等号和一个 - 符号 --flag=xxx 等号和两个 - 符号 其中， -flag xxx 方式最为常用，如果参数是布尔型，只能用等号方式指定 5、flag包命令行帮助 flag 包默认会根据定义的命令行参数，在使用时如果不输入参数就打印对应的帮助信息 这样的帮助信息我们可以对其进行覆盖去改变默认的 Usage package main import ( "flag" "fmt" ) func main() { var host string var port int var verbor bool var help bool // 绑定命令行参数与变量关系 flag.StringVar(&host, "H", "127.0.0.1", "ssh host") flag.IntVar(&port, "P", 22, "ssh port") flag.BoolVar(&verbor, "v", false, "detail log") flag.BoolVar(&help, "h", false, "help") // 自定义-h flag.Usage = func() { fmt.Println(` Usage: flag [-H addr] [-p port] [-v] Options: `) flag.PrintDefaults() } // 解析命令行参数 flag.Parse() if help { flag.Usage() } else { fmt.Println(host, port, verbor) } } /* go run flag_args.go -h Usage: flag [-H addr] [-p port] [-v] Options: -H string ssh host (default "127.0.0.1") -P int ssh port (default 22) -h help -v detail log */ 6、flag定义短参数和长参数 简单来说，短参数和长参数，就是例如我们在使用某些命令时，查看命令版本可以输入 -V ，也可以输入 --version 。这种情况下， flag 并没有默认支持，但是可以通过可以两个选项共享同一个变量来实现，即通过给某个相同的变量设置不同的选项，参数在初始化的时候其顺序是不固定的，因此还需要保证其拥有相同的默认值 package main import ( "fmt" "flag" ) var logLevel string func init() { const ( defaultLogLevel = "DEBUG" usage = "set log level" ) flag.StringVar(&logLevel, "log_level", defaultLogLevel, usage) flag.StringVar(&logLevel, "l", defaultLogLevel, usage + "(shorthand)") } func main() { flag.Parse() fmt.Println("log level:", logLevel) } 通过 const 声明公共的常量，并在默认值以及帮助信息中去使用，这样就可以实现了 7、示例 实现计算字符串或目录下递归计算文件 md5 的命令，类似 linux 的 md5sum 命令 其中利用 bufio 分批次读取文件，防止文件过大时造成资源占用高 package main import ( "bufio" "crypto/md5" "flag" "fmt" "io" "os" "strings" ) func md5reader(reader *bufio.Reader) string { // hasher := md5.New() // 定义MD5 hash计算器 bytes := make([]byte, 1024*1024*10) // 分批次读取文件 for { n, err := reader.Read(bytes) if err != nil { if err != io.EOF { return "" } break } else { hasher.Write(bytes[:n]) } } return fmt.Sprintf("%x", hasher.Sum(nil)) } func md5file(path string) (string, error) { file, err := os.Open(path) if err != nil { return "", err } else { defer file.Close() return md5reader(bufio.NewReader(file)), nil } } func md5str(txt string) (string, error) { return md5reader(bufio.NewReader(strings.NewReader(txt))), nil //return fmt.Sprintf("%x", md5.Sum([]byte(txt))) } func main() { txt := flag.String("s", "", "md5 txt") path := flag.String("f", "", "file path") help := flag.Bool("h", false, "help") flag.Usage = func() { fmt.Println(` Usage: md5 [-s 123abc] [-f path] Options: `) flag.PrintDefaults() } flag.Parse() if *help || *txt == "" && *path == "" { flag.Usage() } else { var md5 string var err error if *path != "" { md5, err = md5file(*path) } else { md5, err = md5str(*txt) } if err != nil { fmt.Println(err) } else { fmt.Println(md5) } } } 编译生成二进制文件 go build -o md5go -x md5_bufio.go ll md5go -rwxr-xr-x 1 ssgeek staff 1.9M Oct 2 00:54 md5go 测试使用 ./md5go -h Usage: md5 [-s 123abc] [-f path] Options: -f string file path -h help -s string md5 txt ./md5go -s 123456 e10adc3949ba59abbe56e057f20f883e ./md5go -f md5_bufio.go 8607a07cbb98cec0e9abe14b0db0bee6 到此这篇关于Golang开发命令行之flag包的使用方法的文章就介绍到这了,更多相关Go语言开发命令行之flag包的使用内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言： 我已经在生产中使用 Go 一段时间了，因为它的构建规模较小，并且由 goroutines 提供的并发性能以及直接在机器上运行构建的能力，所以我非常喜欢它的快速和可靠。 由于标准包的速度非常快，您可以在不使用任何第三方库或框架的情况下构建生产就绪的微服务。这并不是说 Go 中没有提供更多灵活性或速度的框架，只是它们不那么受欢迎。 官方通常告诉你坚持使用标准库。具有讽刺意味的是， golang 框架 的顶级 Google 搜索结果一般都是关于为什么不应该使用标准库。 我对标准库的替代品进行了一些研究和基准测试，以了解它们的表现。我将它们分为我认为是关键的微服务组件。 所有基准测试都在下面列出的配置上运行。虽然正常的基准测试时间只有 1 秒，但我将所有测试运行了 10 秒，以确保每个测试周期都是一致的。 处理器 — 2.7 GHz Intel Core i7 RAM — 16GB — 16 GB 2133 MHz LPDDR3 Bench Time 10s 而不是标准的 1s go test -bench=. -benchtime=10s 1、路由 标准的 http Go 服务器带有一个不错的路由器，可以读取查询参数但不能读取命名参数，例如， /students/:studentID/grades/:gradeID 任何具有上述嵌套资源的 REST 服务都必须使用外部路由库来解析它们。Gin、Echo、Beego、Gorilla Mux 和 Goji 只是其中几个知名框架（根据 Github 关注量）。 其中一些是具有路由功能的成熟中间件框架，而另一些则仅仅只是路由库。 这些库针对单个命名参数进行了测试，结果如下所示，Gin 拥有最快的路由器，Echo 排在第二位。 2、JSON 序列化和反序列化 一旦 API 请求通过路由器并传递到控制器或处理程序，下一步就是在返回响应时对请求 JSON 或 Encode 进行解码。 Go 有一个非常好的encoding包，它支持多种格式，比如json, XML, csv，但是快速浏览一下替代品会向你展示大量的库。我针对标准encoding/json包对 Jsoniter、EasyJson 进行了基准测试，结果如下。 下面是编码的结果，结果表明性能差异并不显着 但是对于解码 JSON，jsoniter执行速度比标准编码包快 5 倍。 现在，如果您的请求已被解码，下一步可能是应用您的业务逻辑，并可能执行一些数据库操作。 3、是否使用ORM框架 大多数流行的语言都依赖于框架来构建与数据库交互的微服务。在 Java 世界中，Hibernate、Active Record for Rails 和 Django ORM 非常流行。ORM（对象关系映射器）有时有助于更好地处理事务、表之间的关系，并有助于避免为简单连接编写复杂的 SQL。 但是 Go 再次拥有一个非常好的database标准库，它使连接到关系数据库变得非常容易，而且速度也非常快。但是，一个痛点是查询。当您查询某些行时，您必须手动映射行中的每个字段，然后将它们分配给struct. 这有效，但很快就会变得混乱并让您编写大量代码。sqlx是一个库，它允许您将整行扫描到您的结构变量中。 虽然sqlx减少了为构建 CRUD 而编写的典型行数，但最终仍会多次编写重复代码。使用 ORM 可以帮助减少它并专注于您的业务逻辑。 database, database + sqlx, gorm , go-pg 对查询进行了基准测试，下面是结果。令人惊讶的是，go-pgORM 的执行速度比标准包甚至sqlx还要快. GORM虽然在生态系统中非常有名，但速度相对较慢。 在 API 调用的每个步骤中，都有更好的框架或外部库，它们将使您的响应更快并提供一定的灵活性。 4、总结 虽然一些外部库的性能改进非常明显，但这不应该成为远离标准库的原因。诸如测试代码的难易程度、开源库的长期维护、团队的学习曲线等都应该考虑在内。尽管如此，我认为像 echo + jsoniter + go-pgGo 等标准库功能的所有令人敬畏的东西将是构建微服务并避免冗余代码的最快方法。 到此这篇关于Golang标准库和外部库的性能比较的文章就介绍到这了,更多相关Go语言标准库和外部库的性能内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

图的实现 所谓图就是节点及其连接关系的集合。所以可以通过一个一维数组表示节点，外加一个二维数组表示节点之间的关系。 //图的矩阵实现typedef struct MGRAPH{ nodes int[]; //节点 edges int[][]; //边 }mGraph; 然而对于一些实际问题，其邻接矩阵中可能存在大量的0值，此时可以通过邻接链表来表示稀疏图，其数据结构如图所示 其左侧为图的示意图，右侧为图的邻接链表。红字表示节点序号，链表中为与这个节点相连的节点，如1节点与2、5节点相连。由于在go中，可以很方便地使用数组来代替链表，所以其链表结构可以写为 package main import "fmt" type Node struct{ value int; //节点为int型 }; type Graph struct{ nodes []*Node edges map[Node][]*Node //邻接表示的无向图 } 其中，map为Go语言中的键值索引类型，其定义格式为map[<op1>]<op2>，<op1>为键，<op2>为值。在图结构中，map[Node][]*Node表示一个Node对应一个Node指针所组成的数组。 下面将通过Go语言生成一个图 //增加节点 //可以理解为Graph的成员函数 func (g *Graph) AddNode(n *Node) { g.nodes = append(g.nodes, n) } //增加边 func (g *Graph) AddEdge(u, v *Node) { g.edges[*u] = append(g.edges[*u],v) //u->v边 g.edges[*v] = append(g.edges[*v],u) //u->v边 } //打印图 func (g *Graph) Print(){ //range遍历 g.nodes，返回索引和值 for _,iNode:=range g.nodes{ fmt.Printf("%v:",iNode.value) for _,next:=range g.edges[*iNode]{ fmt.Printf("%v->",next.value) } fmt.Printf("\n") } } func initGraph() Graph{ g := Graph{} for i:=1;i<=5;i++{ g.AddNode(&Node{i,false}) } //生成边 A := [...]int{1,1,2,2,2,3,4} B := [...]int{2,5,3,4,5,4,5} g.edges = make(map[Node][]*Node)//初始化边 for i:=0;i<7;i++{ g.AddEdge(g.nodes[A[i]-1], g.nodes[B[i]-1]) } return g } func main(){ g := initGraph() g.Print() } 其运行结果为 PS E:\Code> go run .\goGraph.go 1:2->5-> 2:1->3->4->5-> 3:2->4-> 4:2->3->5-> 5:1->2->4-> BFS 广度优先搜索(BFS)是最简单的图搜索算法，给定图的源节点后，向外部进行试探性地搜索。其特点是，通过与源节点的间隔来调控进度，即只有当距离源节点为 k k k的节点被搜索之后，才会继续搜索，得到距离源节点为 k + 1 k+1 k+1的节点。 对于图的搜索而言，可能存在重复的问题，即如果1搜索到2，相应地2又搜索到1，可能就会出现死循环。因此对于图中的节点，我们用searched对其进行标记，当其值为false时，说明没有被搜索过，否则则说明已经搜索过了。 type Node struct{ value int; searched bool; } /*func initGraph() Graph{ g := Graph{} */ //相应地更改节点生成函数 for i:=1;i<=5;i++{ g.AddNode(&Node{i,false}) } /* ... */ 此外，由于在搜索过程中会改变节点的属性，所以map所对应哈希值也会发生变化，即Node作为键值将无法对应原有的邻接节点，所以Graph中边的键值更替为节点的指针，这样即便节点的值发生变化，但其指针不会变化。 type Graph struct{ nodes []*Node edges map[*Node][]*Node //邻接表示的无向图 } //增加边 func (g *Graph) AddEdge(u, v *Node) { g.edges[u] = append(g.edges[u],v) //u->v边 g.edges[v] = append(g.edges[v],u) //u->v边 } //打印图 func (g *Graph) Print(){ //range遍历 g.nodes，返回索引和值 for _,iNode:=range g.nodes{ fmt.Printf("%v:",iNode.value) for _,next:=range g.edges[iNode]{ fmt.Printf("%v->",next.value) } fmt.Printf("\n") } } func initGraph() Graph{ g := Graph{} for i:=1;i<=9;i++{ g.AddNode(&Node{i,false}) } //生成边 A := [...]int{1,1,2,2,2,3,4,5,5,6,1} B := [...]int{2,5,3,4,5,4,5,6,7,8,9} g.edges = make(map[*Node][]*Node)//初始化边 for i:=0;i<11;i++{ g.AddEdge(g.nodes[A[i]-1], g.nodes[B[i]-1]) } return g } func (g *Graph) BFS(n *Node){ var adNodes[] *Node //存储待搜索节点 n.searched = true fmt.Printf("%d:",n.value) for _,iNode:=range g.edges[n]{ if !iNode.searched { adNodes = append(adNodes,iNode) iNode.searched=true fmt.Printf("%v ",iNode.value) } } fmt.Printf("\n") for _,iNode:=range adNodes{ g.BFS(iNode) } } func main(){ g := initGraph() g.Print() g.BFS(g.nodes[0]) } 该图为 输出结果为 PS E:\Code\goStudy> go run .\goGraph.go 1:2->5->9-> 2:1->3->4->5-> 3:2->4-> 4:2->3->5-> 5:1->2->4->6->7-> 6:5->8-> 7:5-> 8:6-> 9:1-> //下面为BFS结果 1:2 5 9 2:3 4 3: 4: 5:6 7 6:8 8: 7: 9: DFS 深度优先遍历(DFS)与BFS的区别在于，后者的搜索过程可以理解为逐层的，即可将我们初始搜索的节点看成父节点，那么与该节点相连接的便是一代节点，搜索完一代节点再搜索二代节点。DFS则是从父节点搜索开始，一直搜索到末代节点，从而得到一个末代节点的一条世系；然后再对所有节点进行遍历，找到另一条世系，直至不存在未搜索过的节点。 其基本步骤为： 首先选定一个未被访问过的顶点 V 0 V_0 V0​作为初始顶点，并将其标记为已访问 然后搜索 V 0 V_0 V0​邻接的所有顶点，判断是否被访问过，如果有未被访问的顶点，则任选一个顶点 V 1 V_1 V1​进行访问，依次类推，直到 V n V_n Vn​不存在未被访问过的节点为止。 若此时图中仍旧有顶点未被访问，则再选取其中一个顶点进行访问，否则遍历结束。 我们先实现第二步，即单个节点的最深搜索结果 func (g *Graph) visitNode(n *Node){ for _,iNode:= range g.edges[n]{ if !iNode.searched{ iNode.searched = true fmt.Printf("%v->",iNode.value) g.visitNode(iNode) return } } } func main(){ g := initGraph() g.nodes[0].searched = true fmt.Printf("%v->",g.nodes[0].value) g.visitNode(g.nodes[0]) } 结果为 PS E:\Code> go run .\goGraph.go 1->2->3->4->5->6->8-> 即 可见，还有节点7、9未被访问。 完整的DFS算法只需在单点遍历之前，加上一个对所有节点的遍历即可 func (g *Graph) DFS(){ for _,iNode:=range g.nodes{ if !iNode.searched{ iNode.searched = true fmt.Printf("%v->",iNode.value) g.visitNode(iNode) fmt.Printf("\n") g.DFS() } } } func main(){ g := initGraph() g.nodes[0].searched = true fmt.Printf("%v->",g.nodes[0].value) g.visitNode(g.nodes[0]) } 结果为 PS E:\Code> go run .\goGraph.go 1->2->3->4->5->6->8-> 7-> 9-> 以上就是Go语言语言编程学习实现图的广度与深度优先搜索的详细内容，更多关于go语言实现图的广度与深度优先搜索的资料请关注M135模板网其它相关文章！ ......查看全文

Go 语言中的 encoding/json 库提供了复杂的将 Go 中各种类型与JSON格式之间转换的功能， 我们主要使用以下几个功能：将一个切片、结构体或字典序列化成 JSON 格式的字符串【字节流】。 将一个 JSON 格式的字符串【字节流】反序列化成一个切片、结构体或字典。 序列化 序列化使用 json 库中的Marshal函数： func Marshal(v interface{}) ([]byte, error) 1. 结构体序列化 比如使用以下的结构体表示一部电影： type Movie struct { Title string Year int `json:"released"` Color bool `json:"color,omitempty"` Actors []string } 定义里类型后面跟的字符串 json:"released"和json:"color,omitempty，称为 field tags，它告诉 json 库在执行序列化时的一些规则： json:"released" 使得在序列化后对应的名字为"released"，而不是"Year"。 json:"color,omitempty"使得如果 Color 成员的值为false，那么就忽略它，不对它进行序列化。 没有 field tags 时进行序列化的一些规则： 如果结构体成员的名字不是以大写字母开头，则不对它进行序列化。 如果结构体成员的名字是以大写字母开头，则序列化后的名字就是成员名。 进行序列化的代码如下： movie := Movie{ Title: "Casablanca", Year: 1942, Color: false, Actors: []string{"Humphrey Bogart", "Ingrid Bergman"}, } data, err := json.Marshal(movie) if err != nil { log.Fatalf("JSON marshaling failed: %s", err) } fmt.Printf("%s\n", data) 输出： {"Title":"Casablanca","released":1942,"Actors":["Humphrey Bogart","Ingrid Bergman"]} 2. 字典序列化 一个字典要想序列化成- JSON 格式，它的 key 必须是字符串。 以下是一个例子： info := map[string]int{ "width": 1280, "height": 720, } data, err := json.MarshalIndent(info, "", " ") if err != nil { log.Fatalf("JSON marshaling failed: %s", err) } fmt.Printf("%s\n", data) 输出： {  "height": 720,  "width": 1280 } 这里我们使用MarshalIndent函数，使得输出后的 JSON 格式更易阅读。序列化后的名字就是字典中 key 的名称。 3. 切片序列化 直接看一个例子： type Movie struct { Title string Year int `json:"released"` Color bool `json:"color,omitempty"` Actors []string } var movies = []Movie{ { Title: "Casablanca", Year: 1942, Color: false, Actors: []string{"Humphrey Bogart", "Ingrid Bergman"}, }, { Title: "Cool Hand Luke", Year: 1967, Color: true, Actors: []string{"Paul Newman"}, }, { Title: "Bullitt", Year: 1968, Color: true, Actors: []string{"Steve McQueen", "Jacqueline Bisset"}, }, } data, err := json.MarshalIndent(movies, "", " ") if err != nil { log.Fatalf("JSON marshaling failed: %s", err) } fmt.Printf("%s\n", data) 输出： [  {   "Title": "Casablanca",   "released": 1942,   "Actors": [    "Humphrey Bogart",    "Ingrid Bergman"   ]  },  {   "Title": "Cool Hand Luke",   "released": 1967,   "color": true,   "Actors": [    "Paul Newman"   ]  },  {   "Title": "Bullitt",   "released": 1968,   "color": true,   "Actors": [    "Steve McQueen",    "Jacqueline Bisset"   ]  } ] 反序列化 反序列化使用Unmarshal函数： func Unmarshal(data []byte, v interface{}) error 1. 明确知道 JSON 格式 我们要先将 JSON 格式表示为一个确定的类型。 1.如下的 JSON 格式： { "name": "Awesome 4K", "resolutions": [ { "width": 1280, "height": 720 }, { "width": 1920, "height": 1080 }, { "width": 3840, "height": 2160 } ] } 我们可以用如下结构体来表示它： struct { Name string Resolutions []struct { Width int Height int } } 2.如下的 JSON 格式： { "height": 720, "width": 1280 } 也可以使用map[string]int，也就是字典来表示。 3.如下的 JSON 格式： [ { "width": 1280, "height": 720 }, { "width": 1920, "height": 1080 }, { "width": 3840, "height": 2160 } ] 使用切片[]map[string]int来表示。 不管怎样，一个确定的JSON格式总是可以使用切片、结构体或字典来表示。 之后就可以执行反序列化了： var jsonBlob = []byte(` [ { "width": 1280, "height": 720 }, { "width": 1920, "height": 1080, }, { "width": 3840, "height": 2160 } ] `) di := []map[string]int{} err = json.Unmarshal(jsonBlob, &di) if err != nil { fmt.Println("error:", err) } fmt.Printf("%+v\n", di) 输出 [map[height:720 width:1280] map[height:1080 width:1920] map[height:2160 width:3840]] 2. 无法确定 JSON 格式 无法确定的格式可以直接使用interface{}类型来表示。这个时候，如果是JSON对象，则反序列化时 json 库会使用map[string]interface{}类型来表示它。如果是JSON数组，则会使用[]interface{}类型来表示它。具体interface{}对应的具体类型，就需要使用类型断言了。 具体看一个示例： package main import ( "encoding/json" "fmt" ) func main() { var jsonBlob = []byte(` { "name": "Awesome 4K", "price": 1999.9, "resolutions": [ { "width": 1280, "height": 720 }, { "width": 1920, "height": 1080 }, { "width": 3840, "height": 2160 } ] } `) var d interface{} err := json.Unmarshal(jsonBlob, &d) if err != nil { fmt.Println("error:", err) } fmt.Println(d) m := d.(map[string]interface{}) for k, v := range m { switch vv := v.(type) { case string: fmt.Println(k, "is string", vv) case float64: fmt.Println(k, "is float64", vv) case []interface{}: fmt.Println(k, "is an array:") for i, u := range vv { fmt.Println(i, u) } default: fmt.Println(k, "is of a type I don't know how to handle") } } } 输出： map[name:Awesome 4K price:1999.9 resolutions:[map[height:720 width:1280] map[height:1080 width:1920] map[height:2160 width:3840]]] resolutions is an array: 0 map[height:720 width:1280] 1 map[height:1080 width:1920] 2 map[height:2160 width:3840] name is string Awesome 4K price is float64 1999.9 到此这篇关于Go 语言 JSON 标准库的使用的文章就介绍到这了,更多相关Go语言 语言 JSON 标准库内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

方法和接收者 Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。 Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集 方法只是一个函数，它带有一个特殊的接收器类型，它是在func关键字和方法名之间编写的。接收器可以是struct类型或非struct类型。接收方可以在方法内部访问。 方法能给用户自定义的类型添加新的行为。它和函数的区别在于方法有一个接收者，给一个函数添加一个接收者，那么它就变成了方法。接收者可以是值接收者，也可以是指针接收者。 在调用方法的时候，值类型既可以调用值接收者的方法，也可以调用指针接收者的方法；指针类型既可以调用指针接收者的方法，也可以调用值接收者的方法。 也就是说，不管方法的接收者是什么类型，该类型的值和指针都可以调用，不必严格符合接收者的类型。 方法的定义格式如下： func (t Type) methodName(parameter)(return) { } 其中 t：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。 Type：接收者类型和参数类似，可以是指针类型和非指针类型。 methodName、parameter 、return ：具体格式与函数定义相同。 //Person 结构体 type Person struct { name string age int8 } //NewPerson 构造函数 func NewPerson(name string, age int8) *Person { return &Person{ name: name, age: age, } } //Dream Person做梦的方法 func (p Person) Dream() { fmt.Printf("%s的梦想是学好Go语言！\n", p.name) } func main() { p1 := NewPerson("张三", 25) p1.Dream() } 方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。 可以定义相同的方法名： type Rectangle struct { width, height float64 } type Circle struct { radius float64 } func (r Rectangle) area() float64 { return r.width * r.height } //该 method 属于 Circle 类型对象中的方法 func (c Circle) area() float64 { return c.radius * c.radius * math.Pi } func main() { r1 := Rectangle{12, 2} r2 := Rectangle{9, 4} c1 := Circle{10} c2 := Circle{25} fmt.Println("Area of r1 is: ", r1.area()) fmt.Println("Area of r2 is: ", r2.area()) fmt.Println("Area of c1 is: ", c1.area()) fmt.Println("Area of c2 is: ", c2.area()) } 运行结果： Area of r1 is:  24 Area of r2 is:  36 Area of c1 is:  314.1592653589793 Area of c2 is:  1963.4954084936207 虽然method的名字一模一样，但是如果接收者不一样，那么method就不一样 method里面可以访问接收者的字段 调用method通过.访问，就像struct里面访问字段一样 指针类型的接收者 指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self： type Rectangle struct { width, height int } func (r *Rectangle) setVal() { r.height = 20 } func main() { p := Rectangle{1, 2} s := p p.setVal() fmt.Println(p.height, s.height) } 结果： 20 2 值类型的接收者 当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。 type Rectangle struct { width, height int } func (r Rectangle) setVal() { r.height = 20 } func main() { p := Rectangle{1, 2} s := p p.setVal() fmt.Println(p.height, s.height) // 2 2 } 什么时候应该使用指针类型接收者 需要修改接收者中的值 接收者是拷贝代价比较大的大对象 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。 方法和函数 已经有了函数，为什么还要使用方法？ type Employee struct { name string salary int currency string } /* displaySalary() method converted to function with Employee as parameter */ func displaySalary(e Employee) { fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary) } func main() { emp1 := Employee{ name: "Sam Adolf", salary: 5000, currency: "$", } displaySalary(emp1) } 在上面的程序中，displaySalary方法被转换为一个函数，而Employee struct作为参数传递给它。这个程序也产生了相同的输出：Salary of Sam Adolf is $5000.。 为什么可以用函数来写相同的程序呢?有以下几个原因： Go不是一种纯粹面向对象的编程语言，它不支持类。因此，类型的方法是一种实现类似于类的行为的方法。 相同名称的方法可以在不同的类型上定义，而具有相同名称的函数是不允许的。 任意类型添加方法 在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。 //MyInt 将int定义为自定义MyInt类型 type MyInt int //SayHello 为MyInt添加一个SayHello的方法 func (m MyInt) SayHello() { fmt.Println("Hello, 我是一个int。") } func main() { var m1 MyInt m1.SayHello() //Hello, 我是一个int。 m1 = 100 fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt } 注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。 方法继承 方法是可以继承的，如果匿名字段实现了一个方法，那么包含这个匿名字段的struct也能调用该方法 type Human struct { name string age int phone string } type Student struct { Human //匿名字段 school string } type Employee struct { Human //匿名字段 company string } func (h *Human) SayHi() { fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone) } func main() { mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"} sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"} mark.SayHi() sam.SayHi() } 运行结果： Hi, I am Mark you can call me on 222-222-YYYY Hi, I am Sam you can call me on 111-888-XXXX 方法重写 type Human struct { name string age int phone string } type Student struct { Human //匿名字段 school string } type Employee struct { Human //匿名字段 company string } //Human定义method func (h *Human) SayHi() { fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone) } //Employee的method重写Human的method func (e *Employee) SayHi() { fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name, e.company, e.phone) //Yes you can split into 2 lines here. } func main() { mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"} sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"} mark.SayHi() sam.SayHi() } 运行结果： Hi, I am Mark you can call me on 222-222-YYYY Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX 方法是可以继承和重写的 存在继承关系时，按照就近原则，进行调用 结构体和方法补充 因为slice和map这两种数据类型都包含了指向底层数据的指针，因此在需要复制它们时要特别注意： type Person struct { name string age int8 dreams []string } func (p *Person) SetDreams(dreams []string) { p.dreams = dreams } func main() { p1 := Person{name: "张三", age: 18} data := []string{"吃饭", "睡觉", "打豆豆"} fmt.Printf("%p\n",data) //0xc00006e360 p1.SetDreams(data) //传的是 data 的内存地址，此时p.dreams和data指向同一块内存空间 fmt.Printf("%p\n",p1.dreams) //0xc00006e360 // 你真的想要修改 p1.dreams 吗？ data[1] = "不睡觉" //data值的修改会影响person结构体的dream字段 fmt.Println(p1.dreams) // [吃饭 不睡觉 打豆豆] } 正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值。 func (p *Person) SetDreams(dreams []string) { p.dreams = make([]string, len(dreams)) copy(p.dreams, dreams) } 同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题。 到此这篇关于Golang通脉方法详情的文章就介绍到这了,更多相关Go语言通脉方法内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1、标识符与关键字 在了解数据类型之前，先了解一下go的标识符和关键字 1.1 标识符 在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等。 Go语言中标识符允许由字母数字和_(下划线）组成，并且只能以字母和_开头：abc , _ , _123, a123。 1.2 关键字 关键字是指语言预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。 Go语言有25个关键字： break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var Go语言中有37个保留字 Constants: true false iota nil Types: int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error Functions: make len cap new append copy close delete complex real imag panic recover 2、变量 2.1 什么是变量 程序运行过程中的数据都是保存在内存中，想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。 所以变量的本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变 变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。 2.2 变量类型 变量（Variable）的功能是存储数据。不同的变量保存的数据类型可能会不一样。常见变量的数据类型有：整型、浮点型、布尔型等。 Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。 2.3 变量声明 Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。 并且Go语言的变量声明后必须使用，否则无法通过编译。 标准声明： Go语言的变量声明格式为： var 变量名 变量类型 变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号： var name string var age int var isTrue bool 批量声明： 每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明： var ( a string b int c bool d float32 ) 变量的初始化： Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，即零值，例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。 当然也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下： var 变量名 类型 = 表达式 var name string = "golang" var age int = 18 或者一次初始化多个变量 var name, age = "golang", 20 类型推导： 有时候会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。 var name = "golang" var age = 18 短变量声明： 在函数内部，可以使用更简略的 := 方式声明并初始化变量。 // 全局变量m var m = 100 func main() { n := 10 m := 200 // 此处声明局部变量m fmt.Println(m, n) } 匿名变量： 在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，例如： func foo() (int, string) { return 10, "golang" } func main() { x, _ := foo() _, y := foo() fmt.Println("x=", x) fmt.Println("y=", y) } 匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 注意事项： 函数外的每个语句都必须以关键字开始（var、const、func等） :=不能使用在函数外，不能定义全局变量，并且左边的变量名至少有一个是新的。 _多用于占位，表示忽略值。 变量必须先定义才能使用，定义了就一定要使用。 变量的类型和赋值的类型必须一致。 变量名在同一个作用于域内不能冲突。 3、常量 相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。 const pi = 3.1415 const e = 2.7182 声明了pi和e这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。 多个常量也可以一起声明： const ( pi = 3.1415 e = 2.7182 ) const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如： const ( n1 = 100 n2 n3 ) 上面示例中，常量n1、n2、n3的值都是100。 常量可以作为枚举，常量组 const ( Unknown = 0 Female = 1 Male = 2 ) 常量组中如不指定类型和初始化值，则与上一行非空常量右值相同 func main() { const ( x uint16 = 16 y s = "abc" z ) fmt.Printf("%T,%v\n", y, y) //uint16,16 fmt.Printf("%T,%v\n", z, z) //string,abc } 常量的注意事项： 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型 不曾使用的常量，在编译的时候，是不会报错的 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值 3.1 iota iota是go语言的常量计数器，是特殊的常量，只能在常量的表达式中使用。 iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。 const ( n1 = iota //0 n2 //1 n3 //2 n4 //3 ) 几个常见的iota示例: 使用_跳过某些值 const ( n1 = iota //0 n2 //1 _ n4 //3 ) iota声明中间插队 const ( n1 = iota //0 n2 = 100 //100 n3 = iota //2 n4 //3 ) const n5 = iota //0 定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。） const ( _ = iota KB = 1 << (10 * iota) MB = 1 << (10 * iota) GB = 1 << (10 * iota) TB = 1 << (10 * iota) PB = 1 << (10 * iota) ) 多个iota定义在一行 const ( a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2 c, d //iota = 1、c = 2, d = 3 e, f //iota = 2、e = 3, f = 4 ) Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。 4、基本数据类型 4.1 整型 整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64 其中，uint8就是byte型，int16对应C语言中的short型，int64对应C语言中的long型。 类型 描述 uint8 无符号 8位整型 (0 到 255) uint16 无符号 16位整型 (0 到 65535) uint32 无符号 32位整型 (0 到 4294967295) uint64 无符号 64位整型 (0 到 18446744073709551615) int8 有符号 8位整型 (-128 到 127) int16 有符号 16位整型 (-32768 到 32767) int32 有符号 32位整型 (-2147483648 到 2147483647) int64 有符号 64位整型 (-9223372036854775808 到 9223372036854775807) 特殊整型： 类型 描述 uint 32位操作系统上就是uint32，64位操作系统上就是uint64 int 32位操作系统上就是int32，64位操作系统上就是int64 uintptr 无符号整型，用于存放一个指针 注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。 大小:32位系统32位，64位系统64位。 范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。 注意事项 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。 数字字面量语法（Number literals syntax） Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如： v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。 而且还允许用 _ 来分隔数字，比如说： v := 123_456 表示 v 的值等于 123456。 将一个整数以不同进制形式展示： func main(){ // 十进制 var a int = 10 fmt.Printf("%d \n", a) // 10 fmt.Printf("%b \n", a) // 1010 占位符%b表示二进制 // 八进制 以0开头 var b int = 077 fmt.Printf("%o \n", b) // 77 // 十六进制 以0x开头 var c int = 0xff fmt.Printf("%x \n", c) // ff fmt.Printf("%X \n", c) // FF } 4.2 浮点型 Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。 打印浮点数时，可以使用fmt包配合动词%f： func main() { fmt.Printf("%f\n", math.Pi) fmt.Printf("%.2f\n", math.Pi) } 4.3 复数 complex64和complex128 var c1 complex64 c1 = 1 + 2i var c2 complex128 c2 = 2 + 3i fmt.Println(c1) fmt.Println(c2) 复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。 4.4 布尔值 Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。 注意： 布尔类型变量的默认值为false。 不允许将整型强制转换为布尔型. 布尔型无法参与数值运算，也无法与其他类型进行转换。 4.5 字符串 Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容，可以在源码中直接添加非ASCII码字符： s1 := "hello" s2 := "你好" 字符串转义符： Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示。 转义符 含义 \r 回车符（返回行首） \n 换行符（直接跳到下一行的同列位置） \t 制表符 \' 单引号 \" 双引号 \\ 反斜杠 打印一个Windows平台下的一个文件路径： func main() { fmt.Println("str := \"d:\\go\\go.exe\"") } 多行字符串： 定义一个多行字符串时，就必须使用反引号字符： s1 := `第一行 第二行 第三行 ` fmt.Println(s1) 反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。 字符串的常用操作： 介绍 方法 求长度 len(str) 拼接字符串 +或fmt.Sprintf 分割 strings.Split 判断是否包含 strings.contains 前缀/后缀判断 strings.HasPrefix,strings.HasSuffix 子串出现的位置 strings.Index(),strings.LastIndex() join操作 strings.Join(a[]string, sep string) 4.6 byte和rune类型 组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（'）包裹起来，如： var a := '中' var b := 'x' Go 语言的字符有以下两种： uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。 rune类型，代表一个 UTF-8字符。 当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。 Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。 因为UTF8编码下一个中文汉字由3~4个字节组成，所以不能简单的按照字节去遍历一个包含中文的字符串 字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。 修改字符串： 要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。 func changeString() { s1 := "big" // 强制类型转换 byteS1 := []byte(s1) byteS1[0] = 'p' fmt.Println(string(byteS1)) s2 := "白萝卜" runeS2 := []rune(s2) runeS2[0] = '红' fmt.Println(string(runeS2)) } 4.7 类型转换 Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。 强制类型转换的基本语法如下： T(表达式) 其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等. func sqrtDemo() { var a, b = 3, 4 var c int // math.Sqrt()接收的参数是float64类型，需要强制转换 c = int(math.Sqrt(float64(a*a + b*b))) fmt.Println(c) } 运算符用于在程序运行时执行数学或逻辑运算。 5、运算符 Go 语言内置的运算符有： 算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 5.1 算数运算符 运算符 描述 + 相加 - 相减 * 相乘 / 相除 % 求余 注意： ++ （自增）和--（自减）在Go语言中是单独的语句，并不是运算符。 5.2 关系运算符 运算符 描述 == 检查两个值是否相等，如果相等返回 True 否则返回 False。 != 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 > 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 >= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 < 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 <= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 5.3 逻辑运算符 运算符 描述 && 逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。 || 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。 ! 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。 5.4 位运算符 位运算符对整数在内存中的二进制位进行操作。 运算符 描述 & 参与运算的两数各对应的二进位相与。 （两位均为1才为1） | 参与运算的两数各对应的二进位相或。 （两位有一个为1就为1） ^ 参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1） &^ 二进制位清空&^ << 左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。 >> 右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。 A B A&B A|B A^B 0 0 0 0 0 0 1 0 1 1 1 1 1 1 0 1 0 0 1 1 5.5 赋值运算符 运算符 描述 示例 = 简单的赋值操作符，分配值从右边的操作数左侧的操作数 C = A + B 将分配A + B的值到C += 相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数 C += A 相当于 C = C + A -= 减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数 C -= A 相当于 C = C - A *= 乘法和赋值运算符，它乘以右边的操作数与左操作数和分配结果左操作数 C *= A 相当于 C = C * A /= 除法赋值运算符，它把左操作数与右操作数和分配结果左操作数 C /= A 相当于 C = C / A %= 模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数 C %= A 相当于 C = C % A <<= 左移位并赋值运算符 C <<= 2 相同于 C = C << 2 >>= 向右移位并赋值运算符 C >>= 2 相同于 C = C >> 2 &= 按位与赋值运算符 C &= 2 相同于 C = C & 2 ^= 按位异或并赋值运算符 C ^= 2 相同于 C = C ^ 2 |= 按位或并赋值运算符 C |= 2 相同于 C = C | 2 5.6 运算符优先级 有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。由上至下代表优先级由高到低： 优先级 运算符 7 ~ ! ++ -- 6 * / % << >> & &^ 5 + - ^ 4 == != < <= >= > 3 <- 2 && 1 || 当然，可以通过使用括号来临时提升某个表达式的整体运算优先级。 到此这篇关于Golang通脉之数据类型详情的文章就介绍到这了,更多相关Go语言 数据类型内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

Go语言中提供的映射关系容器为map，其内部使用散列表（hash）实现。 map 是一种无序的键值对的集合。map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值 map 是一种集合，所以可以像迭代数组和切片那样迭代它。不过，map 是无序的，无法决定它的返回顺序，这是因为 map 是使用 hash 表来实现的，Go语言中的map是引用类型，必须初始化才能使用。 使用map过程中需要注意的几点： map是无序的，每次打印出来的map都会不一样，它不能通过index获取，而必须通过key获取 map的长度是不固定的，也就是和slice一样，也是一种引用类型 内置的len函数同样适用于map，返回map拥有的key的数量 map的key可以是所有可比较的类型，如布尔型、整数型、浮点型、复杂型、字符串型……也可以键。 1、定义 Go语言中 map的定义语法如下： map[KeyType]ValueType 其中 KeyType:表示键的类型。 ValueType:表示键对应的值的类型。 **map类型的变量默认初始值为nil，需要使用make()函数来分配内存 (声明并初始化) **。 语法为： make(map[KeyType]ValueType, [cap]) 其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量。 可以使用内建函数 make ，也可以使用 map 关键字来定义 Map: /* 声明变量，默认 map 是 nil */ var mapVariable map[KeyType]ValueType /* 使用 make 函数 */ mapVariable = make(map[keyType]ValueType) rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 } 如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对 2、基本使用 map中的数据都是成对出现的： func main() { scoreMap := make(map[string]int, 8) scoreMap["张三"] = 90 scoreMap["小明"] = 100 fmt.Println(scoreMap) fmt.Println(scoreMap["小明"]) fmt.Printf("type of a:%T\n", scoreMap) } 输出： map[小明:100 张三:90] 100 type of a:map[string]int map也支持在声明的时候填充元素，例如： func main() { userInfo := map[string]string{ "username": "张三", "password": "123456", } fmt.Println(userInfo) // } 3、判断键是否存在 Go语言中有个判断map中键是否存在的特殊写法，格式如下: value, ok := map[key] func main() { /* 创建集合 */ countryCapitalMap := make(map[string]string) /* map 插入 key-value 对，各个国家对应的首都 */ countryCapitalMap["France"] = "Paris" countryCapitalMap["Italy"] = "Rome" countryCapitalMap["Japan"] = "Tokyo" countryCapitalMap["India"] = "New Delhi" // 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值 v, ok := countryCapitalMap["United States"] if ok { fmt.Println("Capital of United States is", captial) }else { fmt.Println("Capital of United States is not present") } } 4、map的遍历 Go语言中使用for range遍历map。 func main() { countryCapitalMap := make(map[string]string) /* map 插入 key-value 对，各个国家对应的首都 */ countryCapitalMap["France"] = "Paris" countryCapitalMap["Italy"] = "Rome" countryCapitalMap["Japan"] = "Tokyo" countryCapitalMap["India"] = "New Delhi" for k, v := range countryCapitalMap { fmt.Println(k, v) } } 只想遍历key的时候，可以按下面的写法： func main() { countryCapitalMap := make(map[string]string) /* map 插入 key-value 对，各个国家对应的首都 */ countryCapitalMap["France"] = "Paris" countryCapitalMap["Italy"] = "Rome" countryCapitalMap["Japan"] = "Tokyo" countryCapitalMap["India"] = "New Delhi" for k := range countryCapitalMap { fmt.Println(k) } } 注意： 遍历map时的元素顺序与添加键值对的顺序无关。 5、delete()函数删除map元素 使用delete()内建函数从map中删除一组键值对，删除函数不返回任何值，delete()函数的格式如下： delete(map, key) 其中， map:表示要删除键值对的map key:表示要删除的键值对的键 func main(){ countryCapitalMap := make(map[string]string) /* map 插入 key-value 对，各个国家对应的首都 */ countryCapitalMap["France"] = "Paris" countryCapitalMap["Italy"] = "Rome" countryCapitalMap["Japan"] = "Tokyo" countryCapitalMap["India"] = "New Delhi" delete(countryCapitalMap, "France")//将"France":"Paris"从map中删除 for k,v := range scoreMap{ fmt.Println(k, v) } } 6、指定顺序遍历map func main() { rand.Seed(time.Now().UnixNano()) //初始化随机数种子 var scoreMap = make(map[string]int, 200) for i := 0; i < 100; i++ { key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串 value := rand.Intn(100) //生成0~99的随机整数 scoreMap[key] = value } //取出map中的所有key存入切片keys var keys = make([]string, 0, 200) for key := range scoreMap { keys = append(keys, key) } //对切片进行排序 sort.Strings(keys) //按照排序后的key遍历map for _, key := range keys { fmt.Println(key, scoreMap[key]) } } 7、map类型的切片 下面的代码切片中的元素为map类型时的操作： func main() { var mapSlice = make([]map[string]string, 3) for index, value := range mapSlice { fmt.Printf("index:%d value:%v\n", index, value) } fmt.Println("after init") // 对切片中的map元素进行初始化 mapSlice[0] = make(map[string]string, 10) mapSlice[0]["username"] = "张三" mapSlice[0]["password"] = "123456" mapSlice[0]["address"] = "深圳" for index, value := range mapSlice { fmt.Printf("index:%d value:%v\n", index, value) } } 8、value为切片类型的map 下面的代码演示了map中值为切片类型的操作： func main() { var sliceMap = make(map[string][]string, 3) fmt.Println(sliceMap) fmt.Println("after init") key := "中国" value, ok := sliceMap[key] if !ok { value = make([]string, 0, 2) } value = append(value, "北京", "上海") sliceMap[key] = value fmt.Println(sliceMap) } 9、map是引用类型 与切片相似，map是引用类型。当将map分配给一个新变量时，它们都指向相同的内部数据结构。因此，一个的变化会反映另一个： func main() { personSalary := map[string]int{ "steve": 12000, "jamie": 15000, } personSalary["mike"] = 9000 fmt.Println("Original person salary", personSalary) newPersonSalary := personSalary newPersonSalary["mike"] = 18000 fmt.Println("Person salary changed", personSalary) } 运行结果： Original person salary map[steve:12000 jamie:15000 mike:9000]  Person salary changed map[steve:12000 jamie:15000 mike:18000] map不能使用操作符进行比较。只能用来检查map是否为空。否则会报错：invalid operation: map1 == map2 (map can only be comparedto nil) 到此这篇关于Golang通脉之map详情的文章就介绍到这了,更多相关Go语言 map内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

数据结构 channel的数据结构在$GOROOT/src/runtime/chan.go文件下: type hchan struct { qcount uint // 当前队列中剩余元素个数 dataqsiz uint // 环形队列长度，即可以存放的元素个数 buf unsafe.Pointer // 环形队列指针 elemsize uint16 // 每个元素的大小 closed uint32 // 标记是否关闭 elemtype *_type // 元素类型 sendx uint // 队列下标，指向元素写入时存放到队列中的位置 recvx uint // 队列下标，指向元素从队列中读出的位置 recvq waitq // 等待读消息的groutine队列 sendq waitq // 等待写消息的groutine队列 lock mutex // 互斥锁 } chan内部实现了一个环形队列作为缓冲区，队列的长度在创建chan时指定： 等待队列（recvq/sendq）使用双向链表 runtime.waitq 表示，链表中所有的元素都是 runtime.sudog结构： type waitq struct { first *sudog last *sudog } type sudog struct { g *g next *sudog prev *sudog elem unsafe.Pointer // data element (may point to stack) acquiretime int64 releasetime int64 ticket uint32 isSelect bool parent *sudog // semaRoot binary tree waitlink *sudog // g.waiting list or semaRoot waittail *sudog // semaRoot c *hchan // channel } 创建channel 通常使用make(channel string, 0)的方式创建无缓存的channel，使用make(channel string, 10)创建有缓存的channel。 源码： func makechan(t *chantype, size int) *hchan { elem := t.elem // compiler checks this but be safe. if elem.size >= 1<<16 { throw("makechan: invalid channel element type") } if hchanSize%maxAlign != 0 || elem.align > maxAlign { throw("makechan: bad alignment") } mem, overflow := math.MulUintptr(elem.size, uintptr(size)) if overflow || mem > maxAlloc-hchanSize || size < 0 { panic(plainError("makechan: size out of range")) } var c *hchan switch { case mem == 0: // 如果当前 Channel 中不存在缓冲区，那么就只会为 runtime.hchan 分配一段内存空间； c = (*hchan)(mallocgc(hchanSize, nil, true)) c.buf = c.raceaddr() case elem.ptrdata == 0: // 如果当前 Channel 中存储的类型不是指针类型，会为当前的 Channel 和底层的数组分配一块连续的内存空间； c = (*hchan)(mallocgc(hchanSize+mem, nil, true)) c.buf = add(unsafe.Pointer(c), hchanSize) default: //单独为 runtime.hchan 和缓冲区分配内存； c = new(hchan) c.buf = mallocgc(mem, elem, true) } c.elemsize = uint16(elem.size) c.elemtype = elem c.dataqsiz = uint(size) lockInit(&c.lock, lockRankHchan) // 在函数的最后会统一更新elemsize、elemtype 和 dataqsiz 几个字段; if debugChan { print("makechan: chan=", c, "; elemsize=", elem.size, "; dataqsiz=", size, "\n") } return c } channel读写 写 当有新数据来时，首先判断recvq中是否有groutine存在，如果recvq不为空，则说明缓冲区为空，或者没有缓冲区，因为如果缓冲区有数据会被recvq里面的groutine消费。此时从recvq中拿出一个groutine并绑定数据，唤醒该groutine执行任务，这个过程跳过了将数据写入缓冲区的过程。 如果缓冲区有数据并有空余位置，将数据放入缓冲区。 如果缓冲区有数据但没有空余位置，当前groutine绑定数据并放入sendx，进入睡眠，等待被唤醒。 源码： func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool { ..... lock(&c.lock) if c.closed != 0 { unlock(&c.lock) panic(plainError("send on closed channel")) } // 如果Channel 没有被关闭并且已经有处于读等待的 Goroutine， // 那么从接收队列 recvq 中取出最先陷入等待的 Goroutine 并直接向它发送数据 if sg := c.recvq.dequeue(); sg != nil { send(c, sg, ep, func() { unlock(&c.lock) }, 3) return true } // 如果recvq为空且缓冲区中还有剩余空间 if c.qcount < c.dataqsiz { // 计算出下一个可以存储数据的位置， qp := chanbuf(c, c.sendx) // raceenabled: 是否启用数据竞争检测，在编译时指定，默认为false if raceenabled { // 发出数据竞争警告 raceacquire(qp) racerelease(qp) } // 将发送的数据拷贝到缓冲区中，产生内存拷贝 typedmemmove(c.elemtype, qp, ep) // 增加 sendx 索引 c.sendx++ if c.sendx == c.dataqsiz { c.sendx = 0 } // 增加计数器 c.qcount++ unlock(&c.lock) return true } if !block { unlock(&c.lock) return false } // 将channel数据绑定到当前groutine并使groutine休眠 // 获取发送数据使用的 Goroutine gp := getg() // 获取 runtime.sudog 结构并设置这一次阻塞发送的相关信息， // 例如发送的 Channel、是否在 select 中和待发送数据的内存地址等 mysg := acquireSudog() mysg.releasetime = 0 if t0 != 0 { mysg.releasetime = -1 } // 将刚刚创建并初始化的 mysg 加入发送等待队列，并设置到当前 Goroutine的waiting上， // 表示 Goroutine 正在等待该sudog准备就绪 mysg.elem = ep mysg.waitlink = nil mysg.g = gp mysg.isSelect = false mysg.c = c gp.waiting = mysg gp.param = nil c.sendq.enqueue(mysg) // 休眠groutine gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2) // 保证传入的数据不被GC KeepAlive(ep) // someone woke us up. if mysg != gp.waiting { throw("G waiting list is corrupted") } gp.waiting = nil gp.activeStackChans = false if gp.param == nil { if c.closed == 0 { throw("chansend: spurious wakeup") } panic(plainError("send on closed channel")) } gp.param = nil if mysg.releasetime > 0 { blockevent(mysg.releasetime-t0, 2) } mysg.c = nil releaseSudog(mysg) return true } 读 如果sendx不为空且缓冲区不为空，从缓冲区头部读出数据并在当前G执行任务，在sendx中拿出一个G，将其数据写入缓冲区尾部并唤醒该G。 如果sendx不为空且缓冲区为空，直接从sendx中拿出一个G，将G中数据取出并唤醒该G。 如果sendx为空且缓冲区不为空，则从缓冲区头部拿出一个数据。 如果sendx为空且缓冲区为空，将该G放入recvq，进入休眠，等待被唤醒。 源码： func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) { // block：这次接收是否阻塞 if debugChan { print("chanrecv: chan=", c, "\n") } if c == nil { if !block { return } // 从一个空 Channel 接收数据时会直接让出处理器的使用权 gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2) throw("unreachable") } // Fast path: check for failed non-blocking operation without acquiring the lock. if !block && empty(c) { // 如果channel为空并且未关闭，直接返回 if atomic.Load(&c.closed) == 0 { return } if empty(c) { // The channel is irreversibly closed and empty. if raceenabled { raceacquire(c.raceaddr()) } if ep != nil { // 手动标记清楚对象 typedmemclr(c.elemtype, ep) } return true, false } } var t0 int64 if blockprofilerate > 0 { t0 = cputicks() } lock(&c.lock) //如果channel为空，并且已关闭，说明对象不可达 if c.closed != 0 && c.qcount == 0 { if raceenabled { raceacquire(c.raceaddr()) } unlock(&c.lock) if ep != nil { // 手动标记清除 typedmemclr(c.elemtype, ep) } return true, false } // 如果sendq不为空，直接消费，避免sendq --> queue --> recvx的过程 if sg := c.sendq.dequeue(); sg != nil { recv(c, sg, ep, func() { unlock(&c.lock) }, 3) return true, true } // 当 Channel 的缓冲区中已经包含数据时，从 Channel 中接收数据会直接从缓冲区中 // recvx 的索引位置中取出数据进行处理 if c.qcount > 0 { // Receive directly from queue qp := chanbuf(c, c.recvx) if raceenabled { raceacquire(qp) racerelease(qp) } // 如果接收数据的内存地址不为空，那么会使用 runtime.typedmemmove将缓冲区中的数据拷贝到内存中 if ep != nil { typedmemmove(c.elemtype, ep, qp) } // 使用 runtime.typedmemclr清除队列中的数据并完成收尾工作 typedmemclr(c.elemtype, qp) c.recvx++ // recvx位置归零 if c.recvx == c.dataqsiz { c.recvx = 0 } c.qcount-- // 计数减一 unlock(&c.lock) return true, true } if !block { unlock(&c.lock) return false, false } // 当 sendq不为空 并且缓冲区中也不存在任何数据时，阻塞并休眠当前groutine gp := getg() mysg := acquireSudog() mysg.releasetime = 0 if t0 != 0 { mysg.releasetime = -1 } // No stack splits between assigning elem and enqueuing mysg // on gp.waiting where copystack can find it. mysg.elem = ep mysg.waitlink = nil gp.waiting = mysg mysg.g = gp mysg.isSelect = false mysg.c = c gp.param = nil c.recvq.enqueue(mysg) gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2) // someone woke us up if mysg != gp.waiting { throw("G waiting list is corrupted") } gp.waiting = nil gp.activeStackChans = false if mysg.releasetime > 0 { blockevent(mysg.releasetime-t0, 2) } closed := gp.param == nil gp.param = nil mysg.c = nil releaseSudog(mysg) return true, !closed } 到此这篇关于Golang中channel的原理解读的文章就介绍到这了,更多相关Go语言 channel原理内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1、自定义类型 在Go语言中有一些基本的数据类型，如 string 、 整型 、 浮点型 、 布尔 等数据类型， Go语言中可以使用 type 关键字来定义自定义类型。 type是Go语法里的重要而且常用的关键字，type绝不只是对应于C/C++中的typedef。搞清楚type的使用，就容易理解go语言中的核心概念struct、interface、函数等的使用。 2、类型定义 2.1 定义结构体 使用 type 可以定义结构体类型： //1、定义结构体 //结构体定义 type person struct { name string //注意后面不能有逗号 age int } 2.2 定义接口 使用 type 可以定义接口类型： type USB interface { start() end() } 2.3 定义其他的新类型 使用 type ，还可以定义新类型。 语法： type 类型名 Type 示例代码： type myint int type mystr string func main() { var i1 myint var i2 = 100 i1 = 100 fmt.Println(i1) //i1 = i2 //cannot use i2 (type int) as type myint in assignment fmt.Println(i1,i2) var name mystr name = "王二狗" var s1 string s1 = "李小花" fmt.Println(name) fmt.Println(s1) name = s1 //cannot use s1 (type string) as type mystr in assignment } 2.4 定义函数的类型 Go语言支持函数式编程，可以使用高阶编程语法。一个函数可以作为另一个函数的参数，也可以作为另一个函数的返回值，那么在定义这个高阶函数的时候，如果函数的类型比较复杂，可以使用type来定义这个函数的类型： func main() { res1 := fun1() fmt.Println(res1(10,20)) } type my_fun func (int,int)(string) //fun1()函数的返回值是my_func类型 func fun1 () my_fun{ fun := func(a,b int) string { s := strconv.Itoa(a) + strconv.Itoa(b) return s } return fun } 3、类型别名 类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人。 类型别名是 Go 1.9 版本添加的新功能。主要用于代码升级、迁移中类型的兼容性问题。在 C/C++语言中，代码重构升级可以使用宏快速定义新的一段代码。Go 语言中没有选择加入宏，而是将解决重构中最麻烦的类型名变更问题。 type TypeAlias = Type 在 Go 1.9 版本之前的内建类型定义的代码是这样写的： type byte uint8 type rune int32 而在 Go 1.9 版本之后变为： type byte = uint8 type rune = int32 这个修改就是配合类型别名而进行的修改。 4、类型定义和类型别名的区别 类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。 //类型定义 type NewInt int //类型别名 type MyInt = int func main() { var a NewInt var b MyInt fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt fmt.Printf("type of b:%T\n", b) //type of b:int } 结果显示a的类型是 main.NewInt ，表示main包下定义的 NewInt 类型。b的类型是 int 。 MyInt 类型只会在代码中存在，编译完成时并不会有 MyInt 类型。 5、非本地类型不能定义方法 能够随意地为各种类型起名字，是否意味着可以在自己包里为这些类型任意添加方法？ // 定义time.Duration的别名为MyDuration type MyDuration = time.Duration // 为MyDuration添加一个函数 func (m MyDuration) EasySet(a string) { //cannot define new methods on non-local type time.Duration } func main() { } 以上代码报错。报错信息：cannot define new methods on non-local type time.Duration 编译器提示：不能在一个非本地的类型 time.Duration 上定义新方法。非本地方法指的就是使用 time.Duration 的代码所在的包，也就是 main 包。因为 time.Duration 是在 time 包中定义的，在 main 包中使用。time.Duration 包与 main 包不在同一个包中，因此不能为不在一个包中的类型定义方法。 解决这个问题有下面两种方法： 将类型别名改为类型定义： type MyDuration time.Duration ，也就是将 MyDuration 从别名改为类型。 将 MyDuration 的别名定义放在 time 包中。 6、在结构体成员嵌入时使用别名 当类型别名作为结构体嵌入的成员时会发生什么情况？ type Person struct { name string } func (p Person) Show() { fmt.Println("Person-->",p.name) } //类型别名 type People = Person type Student struct { // 嵌入两个结构 Person People } func (p People) Show2(){ fmt.Println("People------>",p.name) } func main() { // var s Student //s.name = "王二狗" //ambiguous selector s.name s.People.name = "李小花" s.Person.name = "王二狗" //s.Show() //ambiguous selector s.Show s.Person.Show() s.People.Show2() fmt.Printf("%T,%T\n",s.Person,s.People) //main.Person,main.Person } 在通过s直接访问name的时候，或者s直接调用Show()方法，因为两个类型都有 name字段和Show() 方法，会发生歧义，证明People 的本质确实是Person 类型。 到此这篇关于Golang通脉之类型定义的文章就介绍到这了,更多相关Go语言 类型定义内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文