将 const 指针传递给函数或 go 通道

一分耕耘，一分收获！既然打开了这篇文章《将 const 指针传递给函数或 go 通道》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

如何将大型结构体的 const 指针传递给函数或 go 通道。 此询问的目的是：

1. 避免函数意外修改指针
2. 在传递给时避免复制结构对象 功能/频道

这个功能在c++、c#、java中很常见，但是我们如何在golang中实现同样的功能呢？

==============更新2 ===================

谢谢@zarkams、@mkopriva 和@peterso 这是编译器优化导致 byvalue() 和 bypointer() 产生相同的结果。 通过添加修改函数 byvalue() 和 bypointer() data.array[0] = reverse(data.array[0])，只是为了让编译器不让函数内联。

func byvalue(data data) int {
    data.array[0] = reverse(data.array[0])
    return len(data.array)
}

func bypointer(data *data) int {
    data.array[0] = reverse(data.array[0])
    return len(data.array)
}

func reverse(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

运行基准测试后，通过指针传递比通过值传递效率更高。

c:\users\anikumar\desktop\testgo>go test -bench=.
goos: windows
goarch: amd64
benchmarkbyvalue-4         18978             58228 ns/op               3 b/op          1 allocs/op
benchmarkbypointer-4    40034295                33.1 ns/op             3 b/op          1 allocs/op
pass
ok      _/c_/users/anikumar/desktop/testgo      3.336s

c:\users\anikumar\desktop\testgo>go test -gcflags -n -run=none -bench=.
goos: windows
goarch: amd64
benchmarkbyvalue-4         20961             59380 ns/op               3 b/op          1 allocs/op
benchmarkbypointer-4    31386213                36.5 ns/op             3 b/op          1 allocs/op
pass
ok      _/c_/users/anikumar/desktop/testgo      3.909s

==============更新===================

根据 @zerkms 的反馈，我创建了一个测试来找出按值复制和按指针复制之间的性能差异。

package main

import (
    "log"
    "time"
)

const size = 99999

// data ...
type data struct {
    array [size]string
}

func main() {
    // preparing large data
    var data data
    for i := 0; i < size; i++ {
        data.array[i] = "this is really long string"
    }

    // starting test
    const max = 9999999999
    start := time.now()
    for i := 0; i < max; i++ {
        byvalue(data)
    }
    elapsed := time.since(start)
    log.printf("by value took %s", elapsed)

    start = time.now()
    for i := 0; i < max; i++ {
        bypointer(&data)
    }
    elapsed = time.since(start)
    log.printf("by pointer took %s", elapsed)
}

func byvalue(data data) int {
    data.array[0] = reverse(data.array[0])
    return len(data.array)
}

func bypointer(data *data) int {
    data.array[0] = reverse(data.array[0])
    return len(data.array)
}

func reverse(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

上述程序迭代 10 次后，我没有发现执行时间有任何差异。

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:52:03 By Value took 5.2798936s
2020/02/16 15:52:09 By Pointer took 5.3466306s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:52:18 By Value took 5.3596692s
2020/02/16 15:52:23 By Pointer took 5.2724685s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:52:29 By Value took 5.2359938s
2020/02/16 15:52:34 By Pointer took 5.2838676s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:52:42 By Value took 5.8374936s
2020/02/16 15:52:49 By Pointer took 6.9524342s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:53:40 By Value took 5.4364867s
2020/02/16 15:53:46 By Pointer took 5.8712875s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:53:54 By Value took 5.5481591s
2020/02/16 15:54:00 By Pointer took 5.5600314s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:54:10 By Value took 5.4753771s
2020/02/16 15:54:16 By Pointer took 6.4368084s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:54:24 By Value took 5.4783356s
2020/02/16 15:54:30 By Pointer took 5.5312314s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:54:39 By Value took 5.4853542s
2020/02/16 15:54:45 By Pointer took 5.5541164s

C:\Users\anikumar\Desktop\TestGo>TestGo.exe
2020/02/16 15:54:57 By Value took 5.4633856s
2020/02/16 15:55:03 By Pointer took 5.4863226s

看来@zerkms 是对的。这不是因为语言，而是因为现代硬件。 罢工>

解决方案

无意义的微基准测试产生无意义的结果。

在 go 中，所有参数都按值传递。

对于您更新的示例（testgo），

$ go version
go version devel +6917529cc6 sat feb 15 16:40:12 2020 +0000 linux/amd64
$ go run microbench.go
2020/02/16 13:12:56 by value took 2.877045229s
2020/02/16 13:12:59 by pointer took 2.875847918s
$

go 编译器通常是优化编译器。例如，

./microbench.go:39:6: can inline byvalue
./microbench.go:43:6: can inline bypointer
./microbench.go:26:10: inlining call to byvalue
./microbench.go:33:12: inlining call to bypointer

没有函数调用开销。因此，执行时间没有差异。

microbench.go：

package main

import (
    "log"
    "time"
)

const size = 99999

// data ...
type data struct {
    array [size]string
}

func main() {
    // preparing large data
    var data data
    for i := 0; i < size; i++ {
        data.array[i] = "this is really long string"
    }

    // starting test
    const max = 9999999999
    start := time.now()
    for i := 0; i < max; i++ {
        byvalue(data)
    }
    elapsed := time.since(start)
    log.printf("by value took %s", elapsed)

    start = time.now()
    for i := 0; i < max; i++ {
        bypointer(&data)
    }
    elapsed = time.since(start)
    log.printf("by pointer took %s", elapsed)
}

func byvalue(data data) int {
    return len(data.array)
}

func bypointer(data *data) int {
    return len(data.array)
}

附录

Comment：@anil8753 另一件需要注意的事情是 go 标准库有一个测试包，它为基准测试提供了一些有用的功能。例如，在 main.go 文件旁边添加一个 main_test.go 文件（文件名很重要）并添加 these two benchmarks to it，然后从文件夹内运行此命令 go test -run=none -bench=.，这将打印有多少个执行了哪些操作、单个操作花费了多少时间、单个操作需要多少内存以及需要多少次分配。 – mkopriva

go 编译器通常是优化编译器。现代硬件通常经过大量优化。

对于 mkopriva 的微基准测试，

$ go test microbench.go mkopriva_test.go -bench=.
benchmarkbyvalue-4     1000000000   0.289 ns/op   0 b/op   0 allocs/op
benchmarkbypointer-4   1000000000   0.575 ns/op   0 b/op   0 allocs/op
$

但是，对于带有接收器的 mkopriva 微基准测试，

$ go test microbench.go sink_test.go -bench=.
benchmarkbyvalue-4     1000000000   0.576 ns/op   0 b/op   0 allocs/op
benchmarkbypointer-4   1000000000   0.592 ns/op   0 b/op   0 allocs/op
$

mkopriva_test.go：

package main

import (
    "testing"
)

func benchmarkbyvalue(b *testing.b) {
    var data data
    b.reportallocs()
    b.resettimer()
    for n := 0; n < b.n; n++ {
        byvalue(data)
    }
}

func benchmarkbypointer(b *testing.b) {
    var data data
    b.reportallocs()
    b.resettimer()
    for n := 0; n < b.n; n++ {
        bypointer(&data)
    }
}

sink_test.go：

package main

import (
    "testing"
)

var banchInt int

func BenchmarkByValue(b *testing.B) {
    var data Data
    b.ReportAllocs()
    b.ResetTimer()
    for n := 0; n < b.N; n++ {
        banchInt = byValue(data)
    }
}

func BenchmarkByPointer(b *testing.B) {
    var data Data
    b.ReportAllocs()
    b.ResetTimer()
    for n := 0; n < b.N; n++ {
        banchInt = byPointer(&data)
    }
}

终于介绍完啦！小伙伴们，这篇关于《将 const 指针传递给函数或 go 通道》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！