我来自Python/Ruby/JavaScript背景。我了解指针的工作原理,但是,我不确定在以下情况下如何利用指针。
假设我们有一个虚构的Web API,该API搜索一些图像数据库并返回一个JSON,该JSON描述在找到的每个图像中显示的内容:
[
{
"url": "https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg",
"description": "Ocean islands",
"tags": [
{"name":"ocean", "rank":1},
{"name":"water", "rank":2},
{"name":"blue", "rank":3},
{"name":"forest", "rank":4}
]
},
...
{
"url": "https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg",
"description": "Bridge over river",
"tags": [
{"name":"bridge", "rank":1},
{"name":"river", "rank":2},
{"name":"water", "rank":3},
{"name":"forest", "rank":4}
]
}
]
我的目标是在Go中创建一个数据结构,该数据结构会将每个标签映射到如下所示的图像URL列表:
{
"ocean": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg"
],
"water": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg",
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
],
"blue": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg"
],
"forest":[
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg",
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
],
"bridge": [
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
],
"river":[
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
]
}
如您所见,每个图像URL可以同时属于多个标签。如果我有成千上万个图像和更多标签,那么如果按每个标签的值复制图像URL字符串,则此数据结构会变得非常大。这是我要利用指针的地方。
我可以用Go中的两个结构来表示JSON API响应,
func searchImages()
模仿了伪造的API:package main
import "fmt"
type Image struct {
URL string
Description string
Tags []*Tag
}
type Tag struct {
Name string
Rank int
}
// this function mimics json.NewDecoder(resp.Body).Decode(&parsedJSON)
func searchImages() []*Image {
parsedJSON := []*Image{
&Image {
URL: "https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg",
Description: "Ocean islands",
Tags: []*Tag{
&Tag{"ocean", 1},
&Tag{"water", 2},
&Tag{"blue", 3},
&Tag{"forest", 4},
},
},
&Image {
URL: "https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg",
Description: "Bridge over river",
Tags: []*Tag{
&Tag{"bridge", 1},
&Tag{"river", 2},
&Tag{"water", 3},
&Tag{"forest", 4},
},
},
}
return parsedJSON
}
现在,导致内存数据结构非常大的次优映射函数如下所示:
func main() {
result := searchImages()
tagToUrlMap := make(map[string][]string)
for _, image := range result {
for _, tag := range image.Tags {
// fmt.Println(image.URL, tag.Name)
tagToUrlMap[tag.Name] = append(tagToUrlMap[tag.Name], image.URL)
}
}
fmt.Println(tagToUrlMap)
}
我可以修改它以使用指向
Image
结构URL
字段的指针,而不是按值复制它: // Version 1
tagToUrlMap := make(map[string][]*string)
for _, image := range result {
for _, tag := range image.Tags {
// fmt.Println(image.URL, tag.Name)
tagToUrlMap[tag.Name] = append(tagToUrlMap[tag.Name], &image.URL)
}
}
它有效,我的第一个问题是,以这种方式构建映射后,
result
数据结构会发生什么?会以某种方式将Image
URL
字符串字段保留在内存中,而其余result
将被垃圾回收吗?还是将result
数据结构保留在内存中直到程序结束,因为某些内容指向其成员?另一种方法是将URL复制到中间变量,然后使用指向它的指针:
// Version 2
tagToUrlMap := make(map[string][]*string)
for _, image := range result {
imageUrl = image.URL
for _, tag := range image.Tags {
// fmt.Println(image.URL, tag.Name)
tagToUrlMap[tag.Name] = append(tagToUrlMap[tag.Name], &imageUrl)
}
}
这是否更好?
result
数据结构会被正确地垃圾回收吗?或者,也许我应该使用一个指向
Image
结构中的字符串的指针代替?type Image struct {
URL *string
Description string
Tags []*Tag
}
有一个更好的方法吗?我还要感谢Go上的任何资源,这些资源都深入描述了指针的各种用法。谢谢!
https://play.golang.org/p/VcKWUYLIpH7
更新:我担心最佳的内存消耗,并且最多不会生成不需要的垃圾。我的目标是使用尽可能少的内存。
最佳答案
前言:我在 github.com/icza/gox
库中释放了呈现的字符串池,请参阅 stringsx.Pool
。
首先介绍一些背景。 Go中的string
值由类似于结构的小型数据结构 reflect.StringHeader
表示:
type StringHeader struct {
Data uintptr
Len int
}
因此,基本上传递/复制
string
值会传递/复制此小struct值,无论string
的长度如何,该值仅为2个字。在64位体系结构上,即使string
具有一千个字符,也只有16个字节。因此,基本上
string
值已充当指针。引入另一个指针(如*string
)只会使用法复杂化,并且您实际上不会获得任何明显的内存。为了优化内存,请不要使用*string
。如果您有一个指向结构值字段的指针值,则整个结构将保留在内存中,无法进行垃圾回收。请注意,尽管可以释放为该结构的其他字段保留的内存,但是当前的Go运行时和垃圾回收器不会这样做。因此,为了获得最佳的内存使用率,您应该忘记存储结构字段的地址(除非您还需要完整的结构值,但是仍然需要特别注意存储字段地址和 slice/数组元素地址)。
这样做的原因是因为用于结构值的内存被分配为连续的段,因此仅保留一个引用的字段会严重破坏可用/可用内存,并使最佳内存管理变得更加困难和效率降低。对这些区域进行碎片整理还需要复制引用字段的存储区域,这将需要“实时更改”指针值(更改存储地址)。
因此,尽管使用指向
string
值的指针可以为您节省一些内存,但是增加的复杂性和附加的间接性使其不值得。那该怎么办呢?
“最佳”解决方案
因此,最干净的方法是继续使用
string
值。还有我们之前没有提到的另一项优化。
您可以通过解码JSON API响应来获得结果。这意味着,如果JSON响应中多次包含相同的URL或标记值,则将为它们创建不同的
string
值。这是什么意思?如果在JSON响应中两次具有相同的URL,则在解码后,您将拥有2个不同的
string
值,其中包含2个不同的指针,这些指针指向2个不同的分配字节序列(否则,字符串内容将是相同的)。 encoding/json
包不进行string
实习。这是一个小应用程序,可以证明这一点:
var s []string
err := json.Unmarshal([]byte(`["abc", "abc", "abc"]`), &s)
if err != nil {
panic(err)
}
for i := range s {
hdr := (*reflect.StringHeader)(unsafe.Pointer(&s[i]))
fmt.Println(hdr.Data)
}
上面的输出(在Go Playground上尝试):
273760312
273760315
273760320
我们看到3个不同的指针。它们可能是相同的,因为
string
值是不可变的。json
包不会检测到重复的string
值,因为这种检测会增加内存和计算开销,这显然是不必要的。但是在我们的案例中,我们追求最佳的内存使用率,因此“初始”的额外计算确实值得获得大的内存增益。因此,让我们做自己的字符串实习。怎么做?
解码JSON结果后,在构建
tagToUrlMap
映射的过程中,让我们跟踪遇到的string
值,并且如果较早看到了后续的string
值,则只需使用该较早的值(其字符串描述符)即可。这是一个非常简单的字符串内部实现:
var cache = map[string]string{}
func interned(s string) string {
if s2, ok := cache[s]; ok {
return s2
}
// New string, store it
cache[s] = s
return s
}
让我们在上面的示例代码中测试这个“interner”:
var s []string
err := json.Unmarshal([]byte(`["abc", "abc", "abc"]`), &s)
if err != nil {
panic(err)
}
for i := range s {
hdr := (*reflect.StringHeader)(unsafe.Pointer(&s[i]))
fmt.Println(hdr.Data, s[i])
}
for i := range s {
s[i] = interned(s[i])
}
for i := range s {
hdr := (*reflect.StringHeader)(unsafe.Pointer(&s[i]))
fmt.Println(hdr.Data, s[i])
}
上面的输出(在Go Playground上尝试):
273760312 abc
273760315 abc
273760320 abc
273760312 abc
273760312 abc
273760312 abc
精彩的!如我们所见,在使用了
interned()
函数之后,我们的数据结构中仅使用了"abc"
字符串的单个实例(实际上是第一次出现)。这意味着所有其他实例(假设没有其他人使用它们)可以(并且将来)将正确地进行垃圾收集(由垃圾收集器,在将来的某个时间)。在这里不要忘记的一件事:字符串交互器使用
cache
字典,该字典存储所有以前遇到的字符串值。因此,要放开这些字符串,您还应该“清除”该缓存映射,最简单的方法是为其分配一个nil
值。事不宜迟,让我们看看我们的解决方案:
result := searchImages()
tagToUrlMap := make(map[string][]string)
for _, image := range result {
imageURL := interned(image.URL)
for _, tag := range image.Tags {
tagName := interned(tag.Name)
tagToUrlMap[tagName] = append(tagToUrlMap[tagName], imageURL)
}
}
// Clear the interner cache:
cache = nil
要验证结果:
enc := json.NewEncoder(os.Stdout)
enc.SetIndent("", " ")
if err := enc.Encode(tagToUrlMap); err != nil {
panic(err)
}
输出为(在Go Playground上尝试):
{
"blue": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg"
],
"bridge": [
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
],
"forest": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg",
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
],
"ocean": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg"
],
"river": [
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
],
"water": [
"https://c8.staticflickr.com/4/3707/11603200203_87810ddb43_o.jpg",
"https://c3.staticflickr.com/1/48/164626048_edeca27ed7_o.jpg"
]
}
进一步的内存优化:
我们使用内置的
append()
函数将新的图像URL添加到标签中。 append()
可能(并且通常确实)分配了比需要的更大的 slice (考虑 future 的增长)。在完成“构建”过程之后,我们可以遍历tagToUrlMap
映射并将这些片段“修剪”到所需的最低限度。这是可以做到的:
for tagName, urls := range tagToUrlMap {
if cap(urls) > len(urls) {
urls2 := make([]string, len(urls))
copy(urls2, urls)
tagToUrlMap[tagName] = urls2
}
}
关于string - 垃圾回收和Go中指针的正确用法,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/51959783/