Go语言--空结构体struct{}解析

Go 专栏收录该内容
19 篇文章 0 订阅

简介

有c/c++学习经历的会发现go的struct语法和c/c++很类型,但是golang的struct{}很有意思。

  1. 做控制而非数据信息: chan struct{}
  2. 实现set: map[string]struct{}

解析

结构体是没有位段的结构体,以下是空结构体的一些例子:

  1. type Q struct{}
  2. var q struct{}

但是如果一个就结构体没有位段,不包含任何数据,那么他的用处是什么?我们能够利用空结构体完成什么任务?

背景

在深入研究空结构体之前,我想先简短的介绍一下关于结构体宽度的知识。

术语宽度来自于gc编译器,但是他的词源可以追溯到几十年以前。

宽度描述了存储一个数据类型实例需要占用的字节数,由于进程的内存空间是一维的,我更倾向于将宽度理解为Size(这个词实在不知道怎么翻译了,请谅解)。

宽度是数据类型的一个属性。Go程序中所有的实例都是一种数据类型,一个实例的宽度是由他的数据类型决定的,通常是8bit的整数倍。

我们可以通过unsafe.Sizeof()函数获取任何实例的宽度:

var s string
var c complex128
fmt.Println(unsafe.Sizeof(s)) // prints 8
fmt.Println(unsafe.Sizeof(c)) // prints 16

数组的宽度是他元素宽度的整数倍。

var a [3]uint32
fmt.Println(unsafe.Sizeof(a)) // prints 12

结构体提供了定义组合类型的灵活方式,组合类型的宽度是字段宽度的和,然后再加上填充宽度。

type S struct {
a uint16
b uint32
}
var s S
fmt.Println(unsafe.Sizeof(s)) // prints 8, not 6

空结构体

现在我们清楚的认识到空结构体的宽度是0,他占用了0字节的内存空间。

var s struct{}
fmt.Println(unsafe.Sizeof(s)) // prints 0

由于空结构体占用0字节,那么空结构体也不需要填充字节。所以空结构体组成的组合数据类型也不会占用内存空间。

type S struct {
A struct{}
B struct{}
}
var s S
fmt.Println(unsafe.Sizeof(s)) // prints 0

空结构体作用

由于Go的正交性,空结构体可以像其他结构体一样正常使用。正常结构体拥有的属性,空结构体一样具有。

你可以定义一个空结构体组成的数组,当然这个切片不占用内存空间。

var x [1000000000]struct{}
fmt.Println(unsafe.Sizeof(x)) // prints 0

空结构体组成的切片的宽度只是他的头部数据的长度,就像上例展示的那样,切片元素不占用内存空间。

var x = make([]struct{}, 1000000000)
fmt.Println(unsafe.Sizeof(x)) // prints 12 in the playground

当然切片的内置子切片、长度和容量等属性依旧可以工作。

ar x = make([]struct{}, 100)
var y = x[:50]
fmt.Println(len(y), cap(y)) // prints 50 100

你甚至可以寻址一个空结构体,空结构体是可寻址的,就像其他类型的实例一样。

var a struct{}
var b = &a

有意思的是两个空结构体的地址可以相等。(go 1.12 版本,不相等) 

var a, b struct{}
fmt.Println(&a == &b) // false

空结构体的元素也具有一样的属性。

a := make([]struct{}, 10)
b := make([]struct{}, 20)
fmt.Println(&a == &b) // false, a and b are different slices
fmt.Println(&a[0] == &b[0]) // true, their backing arrays are the same

为什么会这样?因为空结构体不包含位段,所以不存储数据。如果空结构体不包含数据,那么就没有办法说两个空结构体的值不相等,所以空结构体的值就这样相等了。

a := struct{}{} // not the zero value, a real new struct{} instance
b := struct{}{}
fmt.Println(a == b) // true

空结构体作为接收者

现在让我们展示一下空结构体如何像其他结构体工作,空结构体可以作为方法的接收者。

type S struct{}
func (s *S) addr() { fmt.Printf("%p\n", s) }
func main() {
var a, b S
a.addr() // 0x1beeb0
b.addr() // 0x1beeb0
}

chan struct{}

Go语言中,有一种特殊的struct{}类型的channel,它不能被写入任何数据,只有通过close()函数进行关闭操作,才能进行输出操作。struct{}类型的channel不占用任何内存!!! 
定义:

var sig = make(chan struct{})

使用空 struct 是对内存更友好的开发方式,在 go 源代码中针对 空struct 类数据内存申请部分,返回地址都是一个固定的地址。那么就避免了可能的内存滥用。

栗子:

package main

import "fmt"
import "time"

var strChan = make(chan string,3)

func main(){
    syncChan1 := make(chan struct{},1)  //接收同步变量  
    syncChan2 := make(chan struct{},2) //主线程启动了两个goruntime线程,
                                       //等这两个goruntime线程结束后主线程才能结束

    //用于演示接受操作
    go func(){
        <- syncChan1  //表示可以开始接收数据了,否则等待
        fmt.Println("[receiver] Received a sync signal and wait a second...")
        time.Sleep(time.Second)
        for{
            if elem,ok := <-strChan;ok{
                fmt.Println("[receiver] Received:",elem)
            }else{
                break
            }
        }
        fmt.Println("[receiver] Stopped.")
        syncChan2 <- struct{}{}
    }()

    //用于演示发送操作
    go func(){
        for i,elem := range []string{"a","b","c","d"}{
            fmt.Println("[sender] Sent:",elem)
            strChan <- elem
            if (i+1)%3==0 {
                syncChan1 <- struct{}{}
                fmt.Println("[sender] Sent a sync signal. wait 1 secnd...")
                time.Sleep(time.Second)
            }
        }
        fmt.Println("[sender] wait 2 seconds...")
        time.Sleep(time.Second)
        close(strChan)
        syncChan2 <- struct{}{}
    }()

    //主线程等待发送线程和接收线程结束后再结束
    fmt.Println("[main] waiting...")
    <- syncChan2
    <- syncChan2
    fmt.Println("[main] stoped")
}

运行结果:

[main] waiting...
[sender] Sent: a
[sender] Sent: b
[sender] Sent: c
[sender] Sent a sync signal. wait 1 secnd...
[receiver] Received a sync signal and wait a second...
[receiver] Received: a
[receiver] Received: b
[receiver] Received: c
[sender] Sent: d
[sender] wait 2 seconds...
[receiver] Received: d
[receiver] Stopped.
[main] stoped
  • struch{}代表不包含任何字段的结构体类型,也可称为空结构体类型。在go语言中,空结构体类型是不占用系统内存的,并且所有该类型的变量都拥有相同的内存地址。建议用于传递信号的通道都以struct{}作为元素类型,除非需要传递更多的信息
  • 发送方向通道发送的值会被复制,接收方接收到的总是该值得副本,而不是该值本身。经由通道传递的值最少会被复制一次,最多会被复制两次。例如,当向一个已空的通道发送值,且已有至少一个接收方因此等待时,该通道会绕过本身的缓冲队列,直接把这个值复制给最早等待的那个接收方,这种情况传递的值只复制一次;当从一个已满的通道接收值,且已有至少一个发送方因此等待时,该通道会把缓冲队列中最早进入的那个值复制给接收方,再把最早等待的发送方要发送的数据复制到那个值得原先位置上(通道的缓冲队列属于环形队列,这样做是没有问题的),这种情况传递的值复制两次。
  • 通道传递是复制传递的值。因此如果传递的是值类型,接收方对该值得修改不会影响发送方持有的值;如果传递的是引用类型,则发送方或者接收方对该对象的修改会影响双方所持有的对象

参考:https://dave.cheney.net/2014/03/25/the-empty-struct

End

  • 5
    点赞
  • 4
    评论
  • 9
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值