标签 泛型 下的文章

“类型名称”在Go语言规范中的演变

本文永久链接 – https://tonybai.com/2024/09/24/the-evolution-of-type-name-in-go-spec

Go语言规范(The Go Programming Language Specification)是Go语言的核心文档,定义了该语言的语法、类型系统和运行时行为。Go语言规范的存在使得开发者在实现Go编译器时可以依赖一致的标准,它确保了语言的稳定性和一致性,特别是在类型系统设计中,Go团队通过规范推动了语言的简洁性、稳定性与可维护性。对于Go开发者而言,Go语言规范也是语法特性使用的参考手册(虽然语言规范读起来比较抽象和晦涩)。

Go语言规范由Google的Go核心开发团队维护和演进,这与ISO标准的C/C++语言规范有所不同。C和C++语言的ISO标准更新较慢,需经过复杂的全球共识和审核流程,而相比之下,Go语言的管理方式就显得更加灵活,也能够迅速适应新需求。

然而,这种灵活性也带来了潜在的弊端。随着新语法特性的引入和演进,一些已有的概念的含义可能会发生变化,导致前后的不一致性,从而让开发者感到困惑。例如,Go中的Type Name(类型名称)就经历了从最初的Named Type,到Defined Type和Alias Type,最终又回归到Named Type的过程。

近期Go语言之父之一的Robert Griesemer在Go官博发表了一篇名为”What’s in an (Alias) Name?“的文章,其中就对Go spec中Type Name的历史演进做了回顾,这里我们就基于这段回顾对“类型名称(Type Name)”在Go语言规范中的演变做一下简要梳理,希望能帮助大家更好的理解Go。

1. Go规范中的Type Name(类型名称)

在Go语言规范中,Type Name是指给定类型的标识符,它为一个类型提供了唯一的名称。Type Name用于识别和引用各种类型,这包括Go内置(也叫预声明Predeclared Type)的基础类型(比如int、string)和用户自定义的类型,比如:

var x int       // int是基础类型的Type Name
type MyInt int  // MyInt是用户定义类型的Type Name

你可能会问,Go还有没有类型名称的类型吗?当然有了,有一些特殊的类型没有直接的类型名称。通常,这些类型是匿名类型(Anonymous Type),即它们并没有通过命名来标识,主要的匿名类型包括:

  • 字面量定义的复合类型(Composite Literals)

Go支持在代码中使用复合字面量来定义结构体、数组、切片、map等类型,而不为这些类型显式地定义名称。这些类型是在使用时定义的,并没有为其单独声明一个类型名称。

var data = struct { Name string; Age int }{"Alice", 30}  // 匿名结构体类型
var arr = [5]int{1,2,3,4,5} // 匿名数组类型
var arr = []int{1, 2, 3}  // 匿名切片类型
var m = map[string]int{"foo": 1, "bar": 2}  // 匿名map类型
  • 匿名函数类型

Go支持函数作为一等公民,函数本身可以作为类型,当定义匿名函数(即未命名函数)时,这些函数没有类型名称。

var f = func() int { //匿名函数类型func() int
    return 42
}

Type Name是一个广泛的概念,在Go spec中,Go设计者们将其做了细分,比如Named Type、Defined Type等。那么随着Go版本的变化,Go中的Type Name的分类有哪些重要的演进和变化呢,下面我们就重点说明一下Go spec中Type Name分类的三次重要变化。

2. 初始阶段:简单而明确的Named Type (2009-2017)

Go 1.0是Go语言的首个正式发布版本,其中确立了类型名称的基础概念。在这一阶段,Go的类型系统已经具备了高度的简洁性和一致性,这也是该语言设计的核心原则之一。

在Go语言的早期阶段(2009-2017),Go规范就确定了简单明确的Named Type的概念,它指的是通过下面语法定义的类型T:

type T existingType

这些通过类型声明定义的T被称为Named Type。而这里的existingType可以Predeclared的预声明类型(比如int、string),可以是已存在的Named Type,也可以是前面提到的匿名类型。

通过给现有类型赋予新名称来定义新的类型,与匿名类型等未命名类型形成鲜明对比。这种简单的分类满足了早期Go程序员的需求,为代码组织和类型系统提供了清晰的基础,提升了代码的可读性和模块化。

我们可以用示意图来展示这个阶段的Go类型名称分类:

而Named Type的定义方式也可以用下图表示:

我们看到,可以基于Predeclare Type、匿名类型以及已存在的Named Type来定义一个新的Named Type。并且,Named Type具有一些专有特性,比如可拥有自己的方法、只与自身类型赋值兼容,不与其底层类型直接兼容(除非进行显式类型转换)等。

3. 变革之始:别名类型的引入 (Go 1.9, 2017)

然而,随着Go 1.9在2017年引入别名类型(Alias Type),情况开始变得复杂:

type T = Q // T为Q类型的别名类型

别名类型的引入是为了支持大规模代码库的重构,但它也模糊了Named Type的界限,因为别名也是一个类型名称。

为了应对这一变化,Go团队引入了”Defined Type”的概念以代替界限模糊的Named Type,用以特指通过类型定义(type T Q)创建的新类型。

这样改动后,整个Go类型系统的类型名称分类就变成如下示意图中的状态了:

Defined Type定义和Alias Type的定义分别如下:

两者看起来差别不大,但只有Defined Type才拥有专有属性,比如可拥有自己的方法、只与自身类型赋值兼容等。我们也可以为Alias Type定义方法,但那个方法属于原类型。

4. 泛型时代的到来:概念的重塑 (Go 1.18, 2022)

2022年,Go 1.18的发布标志着Go语言进入了泛型时代,这一重大特性的引入再次挑战了现有的类型分类方式。

比如类型参数也是类型,它们有名称,与Defined Type一样,两个不同命名的类型参数表示不同的类型。换句话说,类型参数是Named Type,而且它们的行为在某些方面与Go原始的Named Type类似。更重要的是,Go的Predeclare Type(如int、string等)只能通过它们的名称来访问,并且像Defined Type和类型参数一样,如果它们的名称不同,它们也会不同,这样预声明的类型也变成了Named Type。

为了适应泛型,Go规范重新引入了Named Type,并将其范围扩大到包括预声明类型、Defined Type、类型参数以及部分情况下的别名类型。

重新引入Named Type后,Defined Type依然得以保留,整个Go系统类型的最新类型名称分类状态如下图所示:

5. 当前的权衡

在”What’s in an (Alias) Name?“的文章中,Robert还提到了学院派类型系统理论中的Nominal type(名义类型)和Structural type(结构类型)两个概念,虽然Go spec目前完全没有使用这两个概念。

Nominal type,也叫名义类型。这种类型的身份(identity)明确地与其名称相关联。两个类型即使结构完全相同,如果名称不同,也被视为不同的类型。像Go 1.18以后spec中的预声明类型(如int、string等)、Defined types(通过type关键字定义的类型)和类型参数都属于这种类型,这大体与Named Type是重叠的。

Structural type(结构类型)的类型的身份仅取决于其结构或组成,而不依赖于名称。如果两个类型的结构相同,它们就被视为相同的类型,即使它们可能有不同的名称,像Go中的接口类型(在某种意义上)、通过类型字面量创建的类型(如匿名结构体、函数类型等)等都可以归属与这种类型。值得注意的是,指向类型字面量的别名类型(如type AliasName = struct{ … })也可看作是structural type。

不过Robert也提到了,后续Go还会继续沿用Named Type、Defined Type等术语,而不会用这些学院派的类型术语来更新Go spec,这主要有几方面考虑:

  • 历史一致性:Go语言从早期就使用了named type、defined type等术语。突然改变可能会导致现有文档、教程和代码库的混乱。
  • 概念特殊性:Go的类型系统有其特殊性,不完全符合传统的nominal/structural二分法。例如,Go的接口类型结合了nominal和structural的特性。这么做,也可以避免引起其他语言中该术语用法的混淆。
  • 实用性考虑:”named type”、”defined type”等术语在Go的上下文中有明确的含义,直接对应于语言的特定特性和语法结构。这使得它们在讨论Go特定概念时更加实用。

6. 小结

本文基于Robert的文章讲述了Go语言类型系统中的类型名称的演变历程。我们回顾了Type Name在Go语言规范中的重要变化,从最初的简单Named Type到后来的Defined Type和Alias Type,再到引入泛型时代后的重新定义Named Type。每一次变化不仅反映了Go语言的不断发展,也展示了Go团队在应对复杂性和保持语言简洁性之间的平衡。


Gopher部落知识星球在2024年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。同时,我们也会加强代码质量和最佳实践的分享,包括如何编写简洁、可读、可测试的Go代码。此外,我们还会加强星友之间的交流和互动。欢迎大家踊跃提问,分享心得,讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落,享受coding的快乐! 欢迎大家踊跃加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily
  • Gopher Daily Feed订阅 – https://gopherdaily.tonybai.com/feed

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go unique包:突破字符串局限的通用值Interning技术实现

本文永久链接 – https://tonybai.com/2024/09/18/understand-go-unique-package-by-example

Go的1.23版本中引入了一个新的标准库包unique,为Go开发者带来了高效的值interning能力。这种能力不仅适用于字符串类型值,还可应用于任何可比较(comparable)类型的值。

本文将简要探讨interning技术及其在Go中的实现方式,通过介绍unique包的功能,帮助读者更好地理解这一技术及其实际应用。

1. 从string interning技术说起

通常提到interning技术时,指的是传统的字符串驻留(string interning)技术。它是一种优化方法,旨在减少程序中重复字符串的内存占用,并提高字符串比较操作的效率。其基本原理是将相同的字符串值在内存中只存储一次,所有对该字符串的引用都指向同一内存地址,而不是为每个相同字符串创建单独的副本。下图展示了使用和不使用string interning技术的对比:

这个图直观地展示了string interning如何通过共享相同的字符串来节省内存和提高效率。我们看到:在不使用string interning的情况下,每个字符串都有自己的内存分配,即使内容相同,比如”Hello”字符串出现两次,占用了两块不同的内存空间。而在使用string interning的情况下,相同内容的字符串只存储一次,比如:两个”Hello”字符串引用指向同一个内存位置。

string interning在多种场景下非常有用,比如在解析文本格式(如XML、JSON)时,interning能高效处理标签名称经常重复的问题;在编译器或解释器的实现时,interning能够减少符号表中的重复项等。

传统的string interning通常使用哈希表或字典来存储字符串的唯一实例。每次出现新字符串时,程序首先会检查哈希表中是否已有相同的字符串,若存在则返回其引用,若不存在则将其存储在表中。

Michael Knyszek在Go官博介绍interning技术时,也给出了一个传统实现的代码片段:

var internPool map[string]string

// Intern returns a string that is equal to s but that may share storage with
// a string previously passed to Intern.
func Intern(s string) string {
    pooled, ok := internPool[s]
    if !ok {
        // Clone the string in case it's part of some much bigger string.
        // This should be rare, if interning is being used well.
        pooled = strings.Clone(s)
        internPool[pooled] = pooled
    }
    return pooled
}

这种实现虽然简单,但Knyszek指出了其存在几个问题:

  • 一旦字符串被intern,就永远不会被释放。
  • 在多goroutine环境下使用需要额外的同步机制。
  • 仅限于字符串类型值,不能用于其他类型的值。

Go 1.23版本引入的unique包就是string interning技术的一种Go官方实现,当然就像前面所说,unique包不仅仅支持传统的string interning,还支持任何支持比较的类型的值的interning。

不过,在介绍unique包之前,我们简单看看这些年来Go社区对interning技术的贡献。

2. Go社区interning技术的实现简史

由于其他主流语言都或多或少有了对string interning的支持,Go社区显然也需要这样的包,在Go issues列表中,我能找到的最早提出在Go中添加interning技术实现的是2013年go核心开发人员Brad Fitzpatrick提出的”proposal: runtime: optionally allow callers to intern strings“。

2019年,Josh Bleecher Snyder发表了一篇博文Interning strings in Go,探讨了interning的Go实现方法,并给出一个简单但重度使用sync.Pool的interning实现,该实现支持对string和字节切片的interning。

2021年,tailscale为了实现可以高效表示ip地址的netaddr包,构建和开源了go4.org/intern包,这是一个可用于量产级别的interning实现。

注:go4.org中这个go4的名字很可能就是因为go4.org这个组织只有四个contributors:Brad Fitzpatrick、Josh Bleecher Snyder、Dave Anderson和Matt Layher。之前的一篇文章《理解unsafe-assume-no-moving-gc包》中的unsafe-assume-no-moving-gc包也是go4.org下面的。

之后,Brad Fitzpatrick将inetaf/netaddr包的实现合并到了Go标准库net/netip中,而netaddr包依赖的go4.org/intern包也被移入Go项目,变为internal/intern包,并被net/netip包所使用。

直到2023年9月,mknyszek提出”unique: new package with unique.Handle“的proposal,给出unique包的API设计和参考实现。unique落地后,原先使用internal/intern包的net/netip也都改为使用unique包了,internal/intern在Go 1.23版本被移除。

接下来,我们来看看这篇文章的主角unique包。

3. Go的unique包介绍

相较于传统的interning实现以及Go社区之前的实现,Go 1.23引入的unique包提供了一个更加通用和高效的interning实现方案。下面我们就分别从API、unique包的优势以及实现原理等几个方面介绍一下这个包。

3.1 unique包的API

从用户角度看,unique包提供的核心API非常简洁:

$go doc unique.Handle
package unique // import "unique"

type Handle[T comparable] struct {
    // Has unexported fields.
}

func Make[T comparable](value T) Handle[T]
func (h Handle[T]) Value() T

Make函数就是unique包的”Intern”函数,它接受一个可比较类型的值,返回一个intern后的值,不过和前面那个传统实现方式的Intern函数不同,Make函数返回的是一个Handle[T]类型的值。针对同一个传给Make函数的值,返回的Handle[T]类型的值是相同的:

// unique-examples/string_interning.go
package main

import "unique"

func main() {
    h1 := unique.Make("hello")
    h2 := unique.Make("hello")
    h3 := unique.Make("hello")
    h4 := unique.Make("golang")
    println(h1 == h2) // true
    println(h1 == h3) // true
    println(h1 == h4) // false
    println(h2 == h4) // false
}

unique包的作者Knyszek认为Handle[T]和Lisp语言中的Symbol十分类似,Symbol在Lisp中是interned后的字符串,Lisp确保相同的字符串只存储一次,提高内存存储和使用效率。

不过前面说了,unique不仅支持字符串值的interning,还支持其他可比较类型的值的interning,下面是一个int interning和一个自定义可比较类型的interning的例子:

// unique-examples/int_interning.go

package main

import "unique"

func main() {
    var a, b int = 5, 6
    h1 := unique.Make(a)
    h2 := unique.Make(a)
    h3 := unique.Make(b)
    println(h1 == h2) // true
    println(h1 == h3) // false
}

// unique-examples/user_type_interning.go

package main

import "unique"

type UserType struct {
    a int
    z float64
    s string
}

func main() {
    var u1 = UserType{
        a: 5,
        z: 3.14,
        s: "golang",
    }
    var u2 = UserType{
        a: 5,
        z: 3.15,
        s: "golang",
    }
    h1 := unique.Make(u1)
    h2 := unique.Make(u1)
    h3 := unique.Make(u2)
    println(h1 == h2) // true
    println(h1 == h3) // false
}

注:如果要intern的类型T是包含指针的结构体,这些指针指向的值几乎总是会逃逸到堆上。

通过Make获得的Handle[T]的Value方法可以获取到interning值的原始值,我们看下面示例:

// unique-examples/value.go
package main

import (
    "fmt"
    "unique"
)

type UserType struct {
    a int
    z float64
    s string
}

func main() {
    var u1 = UserType{
        a: 5,
        z: 3.14,
        s: "golang",
    }
    h1 := unique.Make(u1)
    h2 := unique.Make("hello, golang")
    h3 := unique.Make(567890)
    v1 := h1.Value()
    v2 := h2.Value()
    v3 := h3.Value()
    fmt.Printf("%T: %v\n", v1, v1) // main.UserType: {5 3.14 golang}
    fmt.Printf("%T: %v\n", v2, v2) // string: hello, golang
    fmt.Printf("%T: %v\n", v3, v3) // int: 567890
}

注:Value方法返回的是值的浅拷贝,对于复合类型可能存在共享底层数据的情况。

3.2 unique包的实现原理

传统的字符串interning实现起来可能并不难,但unique包的目标是设计支持可比较类型、interning值也可被GC且支持快速interning值比较的方案,unique包的实现涉及到hashtrimap、细粒度锁以及与runtime内gc相关函数结合的技术难题,因此其门槛还是很高的,即便是Go核心团队成员Knyszek实现的unique包,在Go 1.23发布后也被发现了较为“严重”的bug,该问题将在Go 1.23.2版本修正

下面是一个unique包实现原理的示意图:

上图展示了Make、Handle[T]和Value方法之间的关系,以及它们如何与内部的map(hashtrieMap)交互。

我们看到,图中三次调用Make(“hello”)都返回相同的Handle[string]{ptr1},即无论调用多少次Make,对于相同的输入值,Make总是返回相同的Handle。

图中的Handle[string]{ptr1}是一个包含指向存储”hello”的内存位置指针的结构,所有三次Make调用返回的Handle都指向同一个内存位置。下面是Handle结构体的定义,看了你就明白了这句话的含义:

// $GOROOT/src/unique/handle.go
type Handle[T comparable] struct {
    value *T
}

注:这里Handle内部的指针*T都是strong pointer(强指针),以图中示例,只要有一个Handle实例(由Make返回的)存在,内存中的”hello”就不会被GC。

Handle[string]{ptr1}的Value()方法返回存储的字符串值”hello”。

unique包有一个内部map(hashtrieMap)存储键值对,键是字符串”hello”的clone,值是一个weak.Pointer,指向存储实际字符串值的内存位置。weak.Pointer 是Go 1.23版本的内部包internal/weak中的一个类型,主要用于实现弱指针(weak pointer)的功能。weak.Pointer的主要作用是允许引用一个对象,而不会阻止该对象被垃圾收集器回收。具体来说,它允许你持有一个指向对象的指针,但当该对象的强指针消失时,垃圾收集器仍然可以回收该对象。下面是一张weak Pointer工作机制的示意图,展示了弱指针的生命周期以及对GC行为的影响:

初始状态下,应用创建一个对象,同时创建一个强指针和一个weak.Pointer指向该对象。GC检查对象,但因为存在强指针,所以不能回收。强指针被移除,只剩下weak.Pointer指向对象。GC检查对象,发现没有强指针,于是回收对象。内存被释放,weak.Pointer变为nil。

由于weak包位于internal包中,它只能在Go的标准库或特定包中使用,我们只能用下面的伪代码来展示weak.Pointer的机制:

package main

import (
    "fmt"
    "runtime"
    "unsafe"
    "internal/weak"
)

type MyStruct struct {
    name string
}

func main() {
    // 创建一个对象,obj可以理解为该对象的强指针
    obj := &MyStruct{name: "object1"} 

    // 创建一个weak.Pointer指向obj,weakPtr是对obj指向内存的弱指针
    weakPtr := weak.Make(obj)

    // 显示对象的值,通过强指针和弱指针都可以
    fmt.Println("Before GC:", weakPtr.Value())
    fmt.Println("Before GC:", *obj)

    // 释放原始对象的强指针
    obj = nil

    // 强制执行GC,这时由于弱指针无法阻止GC,obj指向的内存可能被回收
    runtime.GC()

    // 查看弱指针是否仍然有效,这里不能直接使用obj,因为对象可能已经被回收
    fmt.Println("After GC:", weakPtr.Value())
}

弱指针有一些典型的使用场景,比如在缓存机制中,可能希望引用某些对象而不阻止它们被垃圾回收。这样可以在内存不足时自动释放不再使用的缓存对象;又比如在某些场景下,不希望对象长时间驻留在内存中,但仍然希望能够在需要时重新创建或加载它们,即延迟加载的对象;在某些数据结构中(如哈希表或链表),持有强指针可能会导致内存泄漏,弱指针可以有效避免这种情况。

注:目前Knyszek已经提出proposal,将weak包提升为标准库公共API,该proposal已经被accept,最早将在Go 1.24版本落地。

3.3 unique包的优势

从上面示例和原理示意图来看,unique包的设计和实现有几个显著的优势:

  • 泛型支持

通过使用Go的泛型特性,unique包可以处理任何可比较的类型,大大扩展了其应用范围,不再局限于字符串类型。

  • 高效的内存管理

unique包使用了运行时级别的弱指针实现,确保当所有相关的Handle[T](即强指针)都不再被使用时,内部map中的值可以被垃圾回收,这既避免了内存长期占用,也避免了内存泄漏问题。

  • 快速比较操作

Handle[T]类型的比较操作被优化为简单的指针比较,这比直接比较值(特别是对于大型结构体或长字符串内容)要快得多。

3.4 unique包的实际应用

unique包刚刚诞生,目前在Go标准库中的实际应用主要就是在net/netip包中,替代了之前由go4.org/intern移植到标准库中的internal/intern包。

net/netip包使用unique来优化Addr结构体中的addrDetail字段:

type Addr struct {
    // 其他字段...

    // Details about the address, wrapped up together and canonicalized.
    z unique.Handle[addrDetail]
}

// addrDetail represents the details of an Addr, like address family and IPv6 zone.
type addrDetail struct {
    isV6   bool   // IPv4 is false, IPv6 is true.
    zoneV6 string // != "" only if IsV6 is true.
}

// z0, z4, and z6noz are sentinel Addr.z values.
// See the Addr type's field docs.
var (
    z0    unique.Handle[addrDetail]
    z4    = unique.Make(addrDetail{})
    z6noz = unique.Make(addrDetail{isV6: true})
)

// WithZone returns an IP that's the same as ip but with the provided
// zone. If zone is empty, the zone is removed. If ip is an IPv4
// address, WithZone is a no-op and returns ip unchanged.
func (ip Addr) WithZone(zone string) Addr {
    if !ip.Is6() {
        return ip
    }
    if zone == "" {
        ip.z = z6noz
        return ip
    }
    ip.z = unique.Make(addrDetail{isV6: true, zoneV6: zone})
    return ip
}

通过使用unique,net/netip包能够显著减少处理大量IP地址时的内存占用。特别是对于具有相同zone的IPv6地址,内存使用可以大幅降低。

下面我们也通过一个简单的示例来看看使用unique包的内存占用减少的效果。

3.5 内存占用减少的效果

现在我们创建100w个长字符串,这100w个字符串中,有1000种不同的字符串,相当于每种字符串有1000个重复值。下面分别用unique包和不用unique包来演示这个示例,看看内存占用情况:

// unique-examples/effect_with_unique.go 

package main

import (
    "fmt"
    "runtime"
    "strings"
    "unique"
)

const (
    numItems    = 1000000
    stringLen   = 20
    numDistinct = 1000
)

func main() {
    // 创建一些不同的字符串
    distinctStrings := make([]string, numDistinct)
    for i := 0; i < numDistinct; i++ {
        distinctStrings[i] = strings.Repeat(string(rune('A'+i%26)), stringLen)
    }

    // 使用unique包
    withUnique := make([]unique.Handle[string], numItems)
    for i := 0; i < numItems; i++ {
        withUnique[i] = unique.Make(distinctStrings[i%numDistinct])
    }

    runtime.GC() // 强制GC
    printMemUsage("With unique")

    runtime.KeepAlive(withUnique)
}

func printMemUsage(label string) {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("%s:\n", label)
    fmt.Printf("  Alloc = %v MiB\n", bToMb(m.Alloc))
    fmt.Printf("  TotalAlloc = %v MiB\n", bToMb(m.TotalAlloc))
    fmt.Printf("  Sys = %v MiB\n", bToMb(m.Sys))
    fmt.Printf("  HeapAlloc = %v MiB\n", bToMb(m.HeapAlloc))
    fmt.Printf("  HeapSys = %v MiB\n", bToMb(m.HeapSys))
    fmt.Printf("  HeapInuse = %v MiB\n", bToMb(m.HeapInuse))
    fmt.Println()
}

func bToMb(b uint64) uint64 {
    return b / 1024 / 1024
}

// unique-examples/effect_without_unique.go
... 

func main() {
    // 创建一些不同的字符串
    distinctStrings := make([]string, numDistinct)
    for i := 0; i < numDistinct; i++ {
        distinctStrings[i] = strings.Repeat(string(rune('A'+i%26)), stringLen)
    }

    // 不使用unique包
    withoutUnique := make([]string, numItems)
    for i := 0; i < numItems; i++ {
        withoutUnique[i] = distinctStrings[i%numDistinct]
    }

    runtime.GC() // 强制GC以确保准确的内存使用统计
    printMemUsage("Without unique")

    runtime.KeepAlive(withoutUnique)
}

...

下面分别运行这两个源码:

$go run effect_with_unique.go
With unique:
  Alloc = 7 MiB
  TotalAlloc = 7 MiB
  Sys = 15 MiB
  HeapAlloc = 7 MiB
  HeapSys = 11 MiB
  HeapInuse = 8 MiB

$go run effect_without_unique.go
Without unique:
  Alloc = 15 MiB
  TotalAlloc = 15 MiB
  Sys = 22 MiB
  HeapAlloc = 15 MiB
  HeapSys = 19 MiB
  HeapInuse = 15 MiB

这个结果清楚地显示了使用unique包后的内存节省。不使用unique包时,每个重复的字符串都会单独分配内存。而使用unique包后,相同的字符串只会分配一次,大大减少了内存使用。在实际应用中,内存节省的效果可能更加显著,特别是在处理大量重复数据(如日志处理、文本分析等)的场景中。

4. 小结

本文粗略探讨了Go 1.23版本引入的unique包:我们从字符串interning技术说起,介绍了Go社区在interning技术实现方面的努力历程,重点阐述了unique包的API设计、实现原理及其优势。

我们看到:unique包不仅支持传统的字符串interning,还扩展到任何可比较类型的值。其核心API设计简洁,通过Handle[T]类型和Make、Value方法实现了高效的值interning。

在实现原理上,unique包巧妙地结合了hashtrieMap、细粒度锁以及与runtime内gc相关函数,实现了支持可比较类型、interned值可被GC且支持快速比较的方案。

总的来说,unique包为Go开发者提供了一个强大而灵活的interning工具,有望在未来的Go社区项目中得到广泛应用。

本文涉及的源码可以在这里下载。

5. 参考资料


Gopher部落知识星球在2024年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。同时,我们也会加强代码质量和最佳实践的分享,包括如何编写简洁、可读、可测试的Go代码。此外,我们还会加强星友之间的交流和互动。欢迎大家踊跃提问,分享心得,讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落,享受coding的快乐! 欢迎大家踊跃加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily
  • Gopher Daily Feed订阅 – https://gopherdaily.tonybai.com/feed

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats