高效的记忆技巧

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《高效的记忆技巧》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我有两个用 go 编写的类似程序的示例。该代码的主要目的是使用结构中的值对结构进行排序映射。

带有指针的示例

package main

import (
    "fmt"
    "sort"
)

type payload struct {
    data string
    value  float64
}

type container struct {
    counter int
    storage map[int]*payload
}

type payloadslice []*payload

// len is part of sort.interface.
func (p payloadslice) len() int {
    return len(p)
}

// swap is part of sort.interface.
func (p payloadslice) swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

// less is part of sort.interface. we use count as the value to sort by
func (p payloadslice) less(i, j int) bool {
    return p[i].value < p[j].value
}
func main() {
    name := "special_unique_name"
    var m = map[string]container{
        name: {counter: 10, storage: map[int]*payload{
            5: {data: "epsilon", value: 55},8: {data: "theta", value: 85},4: {data: "delta", value: 48},1: {data: "alpha", value: 14},10: {data: "kappa", value: 101},
            3: {data: "gamma", value: 31},6: {data: "zeta", value: 63},2: {data: "beta", value: 26},9: {data: "iota", value: 92},7: {data: "eta", value: 79},
        }},
    }
    s := make(payloadslice, 0, len(m[name].storage))
    for _, v := range m[name].storage {
        s = append(s, v)
    }
    sort.sort(s)

    for _, v := range s {
        fmt.println(name, v)
    }
}

带有值的示例

package main

import (
    "fmt"
    "sort"
)

type payload struct {
    data string
    value  float64
}

type container struct {
    counter int
    storage map[int]payload
}

type payloadSlice []payload

// Len is part of sort.Interface.
func (p payloadSlice) Len() int {
    return len(p)
}

// Swap is part of sort.Interface.
func (p payloadSlice) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

// Less is part of sort.Interface. We use count as the value to sort by
func (p payloadSlice) Less(i, j int) bool {
    return p[i].value < p[j].value
}
func main() {
    name := "special_unique_name"
    var m = map[string]container{
        name: {counter: 10, storage: map[int]payload{
            5: {data: "epsilon", value: 55},8: {data: "theta", value: 85},4: {data: "delta", value: 48},1: {data: "alpha", value: 14},10: {data: "kappa", value: 101},
            3: {data: "gamma", value: 31},6: {data: "zeta", value: 63},2: {data: "beta", value: 26},9: {data: "iota", value: 92},7: {data: "eta", value: 79},
        }},
    }
    s := make(payloadSlice, 0, len(m[name].storage))
    for _, v := range m[name].storage {
        s = append(s, v)
    }
    sort.Sort(s)

    for _, v := range s {
        fmt.Println(name, v)
    }
}

我想知道两个时刻：

1. 哪个示例会节省内存？ （我猜这是一个指针方式）

2. 如何使用映射内具有不同数量结构的测试数据来衡量这些示例的性能？您能帮我创建基准吗？

我认为映射中每个结构体的大小平均在 1-2kb 之间变化。

解决方案

“内存高效”是一个相当广泛的术语，在像 Go 这样具有独立堆和堆栈的垃圾收集语言中可能意味着几个截然不同的事物：

• 什么占用的内存最少？
• 什么会产生最小的 GC 压力？

如果您想最大限度地减少应用程序的占用空间，那么您可能希望在多个作用域（例如多个函数）中使用值时使用指针。这减少了复制，但增加了等于指针大小的开销（64 位系统上为 8 个字节）。

如果您想最大限度地减少 GC 压力，您可能希望仅在需要指针语义或底层值相当大时才使用指针。指针强制将值放到堆上，这会受到垃圾回收的影响，而值可以保留在堆栈上，而堆栈则不会（当函数返回时，堆栈将被完全销毁，这是线程安全的，需要没有参考跟踪）。

“GC 压力”是指堆上创建和销毁的东西越多，垃圾收集器要做的工作就越多，这会占用应用程序正在执行的实际工作的处理器时间。每次在堆上分配时，如果没有空间容纳新值，垃圾收集器将尝试通过在堆上查找不再需要的值来释放空间。在堆上分配的越多，GC 运行的频率就越高，运行时间也就越长。

对于你的第二个问题，你可以（而且应该！）使用 benchmarking facility of the testing package 来衡量针对你的具体情况的各种方法的性能。确保你使用真实的数据和操作进行测试；使用“虚拟”数据类型的微基准或基准不太可能产生任何价值的数据。该包的文档以及通过网络搜索轻松找到的无数博客文章和教程，应该指导您如何在 Go 中编写和使用基准测试的正确方向。

在您的具体情况下，请记住，就这个问题而言，您的数据类型比您想象的要小：在 64 位系统上为 24 个字节，无论字符串的长度如何。为什么？因为 string 在内部是一个包含 int 长度和指向底层字节的指针的结构。当您尝试优化内存使用时，请记住字符串、切片（但不是数组！）和映射都是非常小的结构，包含指向其基础数据的指针。

最重要的是：过早的优化是万恶之源。您应该为两件事编写代码：功能和可读性。当指针语义提供您需要的功能并具有直观的使用意义时，请使用它们。如果您测量资源问题（CPU 或内存），那么您应该分析您的应用程序以查找问题根源、确定问题的优先级并对其进行优化。

在测量并分析性能问题之前，您不会遇到性能问题。

今天关于《高效的记忆技巧》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！