标签 Interface 下的文章

一文告诉你如何判断Go接口变量是否相等

本文永久链接 – https://tonybai.com/2023/02/19/how-to-determine-if-two-interface-vars-are-equal

近日一位《Go语言第一课》专栏的读者向我提出一个问题,代码如下:

func main() {
    printNonEmptyInterface1()
}

type T struct {
    name string
}
func (t T) Error() string {
    return "bad error"
}
func printNonEmptyInterface1() {
    var err1 error    // 非空接口类型
    var err1ptr error // 非空接口类型
    var err2 error    // 非空接口类型
    var err2ptr error // 非空接口类型

    err1 = T{"eden"}
    err1ptr = &T{"eden"}

    err2 = T{"eden"}
    err2ptr = &T{"eden"}

    println("err1:", err1)
    println("err2:", err2)
    println("err1 = err2:", err1 == err2)             // true
    println("err1ptr:", err1ptr)
    println("err2ptr:", err2ptr)
    println("err1ptr = err2ptr:", err1ptr == err2ptr) // false
}

他的问题就是:“当动态类型是指针的时候,接口变量不相等;当动态类型不是指针的时候,接口变量相等,这个怎么理解呢?”。

这个问题让我想到了Go FAQ中那个著名的“nil error != nil”问题,它给很多Go初学者带去了疑惑。让我们先回顾一下GO FAQ中的这个问题的例子代码:

type MyError struct {
    error
}

var ErrBad = MyError{
    error: errors.New("bad things happened"),
}

func bad() bool {
    return false
}

func returnsError() error {
    var p *MyError = nil
    if bad() {
        p = &ErrBad
    }
    return p
}

func main() {
    err := returnsError()
    if err != nil {
        fmt.Printf("error occur: %+v\n", err)
        return
    }
    fmt.Println("ok")
}

运行这个例子,我们将得到:

error occur: <nil>

就“nil error != nil”这个疑问,给大家简单说说如何判断两个接口类型变量是否相等

Go开源已经13年多了!各种渠道的资料也很多了,往往大家稍微深入学习一下,就知道了Go的接口类型在运行时是这样表示的:

// $GOROOT/src/runtime/runtime2.go
type iface struct { // 非空接口类型的运行时表示
    tab  *itab
    data unsafe.Pointer
}

type eface struct { // 空接口类型的运行时表示
    _type *_type
    data  unsafe.Pointer
}

两个结构的共同点是它们都有两个指针字段,第一个字段功能相似,都是表示类型信息的,而第二个指针字段的功能也相同,都是指向当前赋值给该接口类型变量的动态类型变量的值。

这样一来,判断两个接口类型变量是否相等,就是要判断这运行时表示中的类型信息与data信息是否相等。我们可以使用Go内置的println函数来输出接口变量的运行时表示,Go编译器会在编译阶段根据要输出的参数的类型将println替换为特定的运行时函数,这些函数都定义在\$GOROOT/src/runtime/print.go文件中,而针对eface和iface类型的打印函数实现如下:

// $GOROOT/src/runtime/print.go
func printeface(e eface) {
    print("(", e._type, ",", e.data, ")")
}

func printiface(i iface) {
    print("(", i.tab, ",", i.data, ")")
}

我们从printeface和printiface的实现可以看出println会将接口类型变量的类型信息与data信息输出。我们以上面Go FAQ中的例子来说,如果用println输出returnsError返回的error类型变量并与error(nil)作比较,代码如下:

func main() {
    err := returnsError()
    println(err)
    println(error(nil))
    ... ...
}

我们将得到下面输出:

(0x4b7318,0x0) // println(err)
(0x0,0x0) // println(error(nil))

我们看到error(nil)的类型信息部分为nil,而err的类型信息部分是不可空的,因此两者肯定是不相等的,这也是为什么这个例子会输出“意料之外”的“error occur: ”的原因。

我们再回到本文开头的那个例子,运行例子后,输出如下内容:

err1: (0x10c6cc0,0xc000092f20)
err2: (0x10c6cc0,0xc000092f40)
err1 = err2: true
err1ptr: (0x10c6c40,0xc000092f50)
err2ptr: (0x10c6c40,0xc000092f30)
err1ptr = err2ptr: false

我们看到无论接口变量的动态类型是采用指针的,还是采用非指针的,接口类型变量的类型信息部分都相同,data部分都不同。但为什么一个输出true,另外一个输出false呢?

为了找到真正原因,我用lensm工具以图形化方式展示出汇编与源Go代码的对应关系:

注:lensm v0.0.3以前的版本对于Go 1.20版本编译的程序不起作用,无法显示汇编对应的source

从图中我们看到,无论是err1 == err2,还是err1ptr == err2ptr,Go都会调用runtime.ifaceeq来进行比较!我们来看一下ifaceeq的比较逻辑:

// $GOROOT/src/runtime/alg.go
func efaceeq(t *_type, x, y unsafe.Pointer) bool {
      if t == nil {
          return true
      }
      eq := t.equal
      if eq == nil {
          panic(errorString("comparing uncomparable type " + t.string()))
      }
      if isDirectIface(t) {
          // Direct interface types are ptr, chan, map, func, and single-element structs/arrays thereof.
          // Maps and funcs are not comparable, so they can't reach here.
          // Ptrs, chans, and single-element items can be compared directly using ==.
          return x == y
      }
      return eq(x, y)
} 

func ifaceeq(tab *itab, x, y unsafe.Pointer) bool {
    if tab == nil {
        return true
    }
    t := tab._type
    eq := t.equal
    if eq == nil {
        panic(errorString("comparing uncomparable type " + t.string()))
    }
    if isDirectIface(t) {
        // See comment in efaceeq.
        return x == y
    }
    return eq(x, y)
}

这回对于接口类型变量的相等性判断一目了然了(由efaceeq中isDirectIface函数下面的注释可见)!

在两个接口类型变量的类型信息(_type/tab字段)相同的情况下,对于动态类型为指针的类型(direct interface type的一种),直接比对的是两个接口类型变量的类型指针;若为其他非指针类型(Go会额外分配内存存储,data为指向新内存块的指针),则调用类型(_type)信息中的eq函数,eq函数的实现也都是对data解引用后的“==”相等性判断。当然就像Go FAQ中的例子那样,如果两个接口类型变量的类型信息(_type/tab字段)不同,那么两个接口类型变量肯定不等。

好了,这回文章开头的读者疑问可以得到解决了:

  • err1和err2两个接口变量的动态类型都是T,因此比较的是data指向的内存块的值,虽然err1和err2的data字段指向的是两个内存块,但这两个内存块中的T对象值相同(实质就是一个string),因此err1 == err2为true;
  • err1ptr和err2ptr两个接口变量的动态类型都是*T,因此比较的直接就是data的值,显然data值不同,因此err1ptr == err2ptr为false。

这个问题也让我之前对接口变量的“偏差”理解得到了纠正,更多关于接口在运行时表示与接口变量相等性判断的内容大家可以参考《Go语言第一课》专栏第29讲!


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

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://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

聊聊Prometheus Gauge的增减操作实现

本文永久链接 – https://tonybai.com/2023/01/10/how-prometheus-gauge-add-and-sub

1. Gauge是啥?

熟悉Prometheus的小伙伴们都知道Prometheus提供了四大指标类型

  • Counter
  • Gauge
  • Histogram
  • Summary

Histogram和Summary是一类,但理解起来稍复杂一些,这里我们暂且不提。Counter顾名思义“计数器”,仅提供了Add方法,是一个一直递增的数值;而Gauge直译为“仪表盘”,它也是一个数值,但和Counter不同,它不仅提供Add方法,还提供了Sub方法。如果你的指标可增可减或是需要支持负数,那么Gauge显然是一个比Counter更适合的指标类型。

近期我们在测试时发现一个Gauge值为负的问题,Gauge本身是支持负值的,但我们系统中的这个指标值从业务含义上来说是不应该为负值的,为了fix掉这个问题,我深入看了一下Prometheus Go client包中Gauge的实现方式,Gauge的实现方式代表了一类问题的典型解决方法,这里简单聊聊。

2. Gauge增减操作的原理

在Prometheus Go client包中,我们看到Gauge是一个接口类型:

// github.com/prometheus/client_golang/prometheus/gauge.go
type Gauge interface {
    Metric
    Collector

    // Set sets the Gauge to an arbitrary value.
    Set(float64)
    // Inc increments the Gauge by 1. Use Add to increment it by arbitrary
    // values.
    Inc()
    // Dec decrements the Gauge by 1. Use Sub to decrement it by arbitrary
    // values.
    Dec()
    // Add adds the given value to the Gauge. (The value can be negative,
    // resulting in a decrease of the Gauge.)
    Add(float64)
    // Sub subtracts the given value from the Gauge. (The value can be
    // negative, resulting in an increase of the Gauge.)
    Sub(float64)

    // SetToCurrentTime sets the Gauge to the current Unix time in seconds.
    SetToCurrentTime()
}

client包还提供了该接口的默认实现类型gauge:

// github.com/prometheus/client_golang/prometheus/gauge.go
type gauge struct {
    // valBits contains the bits of the represented float64 value. It has
    // to go first in the struct to guarantee alignment for atomic
    // operations.  http://golang.org/pkg/sync/atomic/#pkg-note-BUG
    valBits uint64

    selfCollector

    desc       *Desc
    labelPairs []*dto.LabelPair
}

从gauge类型定义来看,作为仪表盘即时数值的gauge,其核心字段是uint64类型的valBits,该字段存储了gauge指标所代表的即时值

不过我们看到Gauge接口类型中的Add和Sub方法的参数都是float64类型。Gauge接口类型中的方法使用float64类型作为参数是无可厚非的,这是因为Gauge要支持浮点数,要支持小数,浮点数可以转化为整型,但整型却无法支持转换为带有小数部分的浮点数。

那么为什么gauge类型中使用了uint64类型而不是float64类型的字段来存储gauge代表的即时值呢?这就要从Prometheus go client的一个特性说起,那就是对Gauge即时值的修改要保证goroutine-safe。具体来说,gauge使用的是atomic包提供的原子操作来保证这种并发访问安全。但标准库的atomic包支持uint64类型的原子操作,而不支持float64类型的原子操作,恰float64和uint64的size又都是8字节,于是Prometheus go client利用了uint64支持原子操作以及uint64和float64类型都是64bits长度这两点实现了gauge类型的Add和Sub方法:

// github.com/prometheus/client_golang/prometheus/gauge.go

func (g *gauge) Add(val float64) {
    for {
        oldBits := atomic.LoadUint64(&g.valBits)
        newBits := math.Float64bits(math.Float64frombits(oldBits) + val)
        if atomic.CompareAndSwapUint64(&g.valBits, oldBits, newBits) {
            return
        }
    }
}

func (g *gauge) Sub(val float64) {
    g.Add(val * -1)
}

我们看到Sub方法实际调用的也是Add方法,只是将val值乘了个-1后作为Add方法的参数。我们接下来重点来看看gauge的Add方法。

gauge Add方法的实现是一个典型的CAS(CompareAndSwap)原子操作的使用模式,即在一个无限循环中,先原子读取当前即时值,然后将其与传入的增量值进行加和得到新值,最后通过CAS操作将新值设置为当前即时值。如果CAS操作失败,则重新走一遍循环。

不过值得我们关注的是Add方法中的float64与uint64类型各自的功用与相互的转换。Add方法先是利用atomic.LoadUint64原子读取valBits的值,然后通过math.Float64frombits将其转换为float64类型,之后用得到的float64类型即时值与val进行加法运算,得到我们想要的新值。接下来就是将其重新存储到valBits中。float64不支持原子操作,因此再调用CAS之前,Add方法还需将新值转换回uint64,这就是上面代码调用math.Float64bits的原因,之后通过atomic.CompareAndSwapUint64将保存了float64位模式的uint64类型的新值newBits写入valBits中。

大家一定很好奇,math.Float64frombits和math.Float64bits是如何做的uint64和float64间的转换,我们来看一下他们的实现:

// $GOROOT/src/math/unsafe.go

// Float64bits returns the IEEE 754 binary representation of f,
// with the sign bit of f and the result in the same bit position,
// and Float64bits(Float64frombits(x)) == x.
func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }

// Float64frombits returns the floating-point number corresponding
// to the IEEE 754 binary representation b, with the sign bit of b
// and the result in the same bit position.
// Float64frombits(Float64bits(x)) == x.
func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }

我们看到,这两个函数只是利用unsafe包进行了类型转换,而并没有做任何算术运算。

关于如何使用unsafe包进行安全的类型转换,可以参见我的《Go语言精进之路》一书的第58条“掌握unsafe包的安全使用模式”。

综上:

  • gauge结构体中uint64类型的valBits实质上只是用来做float64数值的“承载体”,并借助原子操作对其类型的支持实现即时值的更新,它本身并不参与任何整型或浮点型计算;
  • Add方法中的运算都是在浮点型之间进行的,Add方法通过math.Float64frombits将uint64中承载的符合IEEE 754的浮点数表示还原为一个浮点数类型,然后与同样是float64类型的输入参数进行加和计算,计算的结果再通过math.Float64bits函数转换为uint64类型,这个过程8字节字段的位模式没有发生任何变化,最后通过CAS操作将结果值(新的位模式)写入valBits。

valBits中存储的是满足IEEE 754的浮点数的位模式。IEEE 754规范中,一个浮点数是由“符号位+阶码+尾数”构成的。详情可参考我的《Go语言第一课》专栏的第12讲基本数据类型:Go原生支持的数值类型有哪些

3. 小结

gauge结构体以及其Add方法所使用的这种通过位模式转换实现float64原子操作的模式值得借鉴。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

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://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! 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

文章

评论

  • 正在加载...

分类

标签

归档



Statcounter View My Stats