1 简介

在Go语言中，大小为0的struct{}{}（空结构体）有几个经典的应用。它们主要用于表示不占用存储空间的状态信息或标志。本文试图介绍它的一些用途。

空结构体占用0字节的原因。

• 无字段定义：

空结构体没有任何字段，因此它没有实际的数据需要存储。这意味着在内存中，空结构体的实例不需要占用任何空间。

• 特殊用途：

空结构体在Go语言中主要用于特定的用途，比如作为集合中的唯一标识符（如map的键）、用于同步操作、或作为信号机制。因为它不携带任何数据，所以内存使用上是最优的。

• 编译器优化：

Go语言的编译器会将空结构体的内存占用优化为0字节。

虽然在程序中可能会使用空结构体来创建数据结构（如通道的接收缓冲区、集合中的唯一标识符），但是这些数据结构的内存开销完全由其他数据结构（如切片、映射等）管理，空结构体本身并不占用额外的空间。

• 内存对齐：

通常，结构体的内存对齐和大小由其最大字段的大小决定。然而，在空结构体的情况下，没有字段，内存对齐和大小可以为0，表示它不占用内存。

以下是一个示例，展示了如何使用unsafe.Sizeof来验证空结构体的大小：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var emptyStruct struct{}
    fmt.Printf("Size of empty struct: %d bytes\n", unsafe.Sizeof(emptyStruct))
}

运行上述代码，输出结果如下：

Size of empty struct: 0 bytes 

空结构体 struct{}{} 在Go语言中是一个特殊的结构体类型，不包含任何字段。

内存优化：由于没有数据字段，编译器优化了空结构体的内存占用，使其在内存中占用0字节。

用途：空结构体通常用于需要存在唯一标识符但不需要实际存储数据的场景。

这种设计使得Go语言能够有效地利用内存，并在需要时提供一种简单而有效的数据结构。

2 经典应用：实现集合和同步

下面是一些典型的应用和Go标准库中的例子：

• 用于实现集合（Set）：

使用map[T]struct{}{}来实现集合，而不是map[T]bool。这样可以节省空间，因为struct{}{}不占用内存。

    // 集合的示例实现
    set := make(map[string]struct{})
    set["element"] = struct{}{}

    // 检查是否存在
    if _, ok := set["element"]; ok {
        fmt.Println("Element exists")
    }

• 用于信号和同步：

在并发编程中，使用struct{}{}作为通道的元素类型，表示仅传递信号而不传递实际数据。

    done := make(chan struct{})

    go func() {
        // 执行一些操作
        done <- struct{}{}
    }()

    <-done

在某些情况下，也可以通过使用空结构体来避免内存分配。例如，某些类型的缓存实现中使用。

3 标准库中的应用

• context包：

context包中使用struct{}{}来表示完成信号。

    type emptyCtx struct{}
    func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
            return
        }

• sync包：

sync包中的Cond结构体使用struct{}{}来表示信号。

    var locker sync.Mutex
    var cond = sync.NewCond(&locker)

    // goroutine1
    go func() {
        cond.L.Lock()
        cond.Wait()
        // 被唤醒后执行的操作
        cond.L.Unlock()
    }()

    // goroutine2
    go func() {
        cond.L.Lock()
        cond.Signal()
        cond.L.Unlock()
    }()

其中 Cond 结构体定义如下：

    type Cond struct {
        noCopy noCopy

        // L is held while observing or changing the condition
        L Locker

        notify  notifyList
        checker copyChecker
    }

字段 noCopy 使用 struct{}

    type noCopy struct{}

4 与其他数据类型的结合使用

在Go语言中，除了struct{}{}外，还可以其他类型的值，使其大小也为0。

以下是一些示例：

• 空接口：

空接口interface{}不包含任何方法集，其值为0大小（但是占有内存空间16字节）。

空接口interface{}虽然不包含任何方法集，但是它在内存中并不占0字节的空间。实际上，空接口在内存中占用的空间是16字节（在64位系统上），因为它包含两个指针：一个指向类型信息，另一个指向具体的值。

空接口interface{}在Go语言中表示可以存储任何类型的值。为了实现这一点，空接口实际上是一个结构体，包含两个字段：

类型信息指针：指向存储在接口中的值的类型信息。
数据指针：指向实际存储的值。

在64位系统上，每个指针占用8字节，因此一个空接口总共占用16字节的内存空间。

以下是一个示例代码，展示了如何使用unsafe.Sizeof来获取空接口在内存中的大小：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var emptyInterface interface{}
    fmt.Printf("Size of empty interface: %d bytes\n", unsafe.Sizeof(emptyInterface))
}

运行上述代码，输出结果如下（在64位系统上）：

    Size of empty interface: 16 bytes

这个结果表明，一个空接口在64位系统上占用16字节的内存空间。这是因为空接口包含两个指针，每个指针占用8字节，总共16字节。

• 接口的值大小为0

虽然空接口本身占用一定的内存空间（用于存储类型信息和指向值的指针），但它指向的值（如空结构体）可以占用0字节。

var emptyStruct struct{}
var emptyInterface interface{} = emptyStruct

// 获取空结构体的大小
sizeOfEmptyStruct := unsafe.Sizeof(emptyStruct)
fmt.Printf("Size of empty struct: %d bytes\n", sizeOfEmptyStruct)

// 获取空接口的大小
sizeOfEmptyInterface := unsafe.Sizeof(emptyInterface)
fmt.Printf("Size of empty interface: %d bytes\n", sizeOfEmptyInterface)

// 断言空接口中的值并获取其大小
if s, ok := emptyInterface.(struct{}); ok {
    sizeOfAssertedStruct := unsafe.Sizeof(s)
    fmt.Printf("Size of asserted struct: %d bytes\n", sizeOfAssertedStruct)
} else {
    fmt.Println("Failed to assert type struct{}")
}

• 通道类型：

空通道chan struct{}{}，因为仅表示一种同步机制，而不包含实际的数据存储。

通道（channel）本质上是一个指向内部数据结构的指针。
这个指针的大小在64位系统上通常为8字节，在32位系统上为4字节.
可以使用unsafe.Sizeof来查看通道在内存中的大小。

下面是一个示例代码，展示了如何获取通道的大小：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var ch chan int
    fmt.Printf("Size of nil chan: %d bytes\n", unsafe.Sizeof(ch))
}

运行上述代码，输出结果如下（在64位系统上）：

Size of nil chan: 8 bytes

这个结果表明，通道在64位系统上占用8字节的内存空间。这是因为通道变量实际上是一个指针，指向由运行时系统管理的内部数据结构。

通道内部结构

虽然通道的内部实现细节在标准库中是隐藏的，但我们可以通过查看Go语言的源代码来了解其内部结构。在Go语言的运行时包（runtime）中，通道的数据结构定义如下（简化版）：

type hchan struct {
    qcount   uint           // 队列中的元素数量
    dataqsiz uint           // 环形缓冲区的大小
    buf      unsafe.Pointer // 环形缓冲区的指针
    elemsize uint16         // 每个元素的大小
    closed   uint32         // 通道是否已关闭
    // 其他字段...
}

上述数据结构hchan描述了通道的内部实现。通道变量chan类型实际上是一个指向hchan结构体的指针。在64位系统上，这个指针的大小为8字节。

• 函数类型：

函数类型func(){}，因为它们仅表示代码的入口点而不包含数据。

函数变量的内部结构，在Go语言中，函数变量（即函数类型的值）实际上是一个指向函数体的指针。

函数在内存中的表示包括：

函数指针：

    函数变量在运行时是一个指向函数体的指针。即使函数体为空，仍然需要一个指针来指向函数体的存储位置。

函数上下文：

除了函数体本身，Go语言的函数还可能包含其他上下文信息，例如闭包信息（如果函数是一个闭包）和运行时数据。这些信息可能需要额外的内存来管理。

内存占用的原因

指针大小：

在64位系统上，指针的大小通常为8字节。这意味着任何存储函数指针的变量（无论函数体是否为空）都将占用8字节。

运行时管理：

Go运行时系统需要管理函数的调用和执行。即使函数体为空，函数的指针仍然指向一个有效的函数体位置，并且Go运行时需要维护这个函数的信息。为了支持这种管理，函数变量需要占用一定的内存空间。

因此空函数 func() {} 可能不包含任何实际代码，但是函数变量本身仍然需要8字节来存储指向函数体的指针（在64位系统上）。这与函数体的内容无关，只与指针的大小有关。

5 小结

通过上述代码示例和对通道内部结构的简要介绍，我们可以确定：

空结构体在go语言中由于没有任何信息需要表示，占有内存空间为0.

空接口interface{}虽然不包含任何方法集，
但它在内存中占用的空间并不是0字节，而是在64位系统上占用16字节。
这是因为空接口需要存储指向类型信息和具体值的两个指针。

定义的空通道和空的函数变量本身是一个指向内部数据结构的指针，占有内存大小8节字（64位系统）。

在64位系统上，指针的大小为8字节，因此通道变量的大小为8字节。

在64位系统，由于要表示 2^64 个不同的地址，你需要64位的地址总线。64位的地址总线需要64位的信息来唯一地标识每一个地址。

由于1字节等于8位，因此64位的信息需要 64/8=8 字节来存储。因此64位系统中的每个指针需要8字节来存储地址信息。

这就是为什么在64位系统上，通道变量的大小是8字节，而在32位系统通道变量大小为4字节的原因。

通过本文示例和应用，可以看到空结构体在Go语言中有着广泛的应用，并且在设计高效的数据结构和并发机制中起到了重要的作用。