编程

Empty Struct

Go 语言空结构体(struct{})详解与高性能应用

空结构体(struct{})是 Go 语言中一个特殊且非常实用的数据类型，它在高性能编程中有着广泛的应用。本文将详细介绍空结构体的特点及其常见使用场景。

1. 空结构体的内存占用

Go 语言中的空结构体是一个不包含任何字段的结构体，定义为struct{}。它最显著的特点是不占用任何内存空间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var s struct{}
    fmt.Println(unsafe.Sizeof(s)) // 输出: 0
}

空结构体不占用内存空间的特性使其在需要占位符但不需要存储任何值的场景中非常有用。

2. 空结构体的内部实现原理

虽然空结构体不占用内存，但 Go 语言运行时仍然为所有的空结构体实例提供了一个唯一的内存地址。这个地址由运行时维护，所有空结构体实例共享这一个地址。

在 Go 的源代码中(runtime/malloc.go)有一个特殊的全局变量zerobase，它作为所有空结构体实例的内存地址：

1
2

// runtime/malloc.go (简化版)
var zerobase uintptr

这就是为什么所有的空结构体实例不占用额外内存，因为它们全部指向这个预先分配好的地址。

3. 空结构体的应用场景

3.1 实现集合(Set)数据结构

Go 语言标准库没有内置 Set 类型，通常使用map[T]bool来模拟集合功能。但使用空结构体作为 map 的值可以节省内存：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import "fmt"

// Set 是一个使用map实现的集合类型
type Set map[string]struct{}

// Has 判断元素是否存在于集合中
func (s Set) Has(key string) bool {
    _, ok := s[key]
    return ok
}

// Add 向集合添加元素
func (s Set) Add(key string) {
    s[key] = struct{}{}
}

// Delete 从集合删除元素
func (s Set) Delete(key string) {
    delete(s, key)
}

func main() {
    s := make(Set)
    s.Add("北京")
    s.Add("上海")
    s.Add("广州")

    fmt.Println("集合包含上海:", s.Has("上海"))     // 输出: true
    fmt.Println("集合包含深圳:", s.Has("深圳"))     // 输出: false

    s.Delete("上海")
    fmt.Println("删除后集合包含上海:", s.Has("上海")) // 输出: false
}

这种实现比使用map[string]bool更加节省内存。假设有一百万个元素的集合，使用bool类型会额外消耗约 1MB 的内存，而使用空结构体则完全不需要这部分内存。

3.2 信号通知的通道(Channel)

空结构体常用于仅需要通知事件发生而不需要传递数据的通道：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
    "fmt"
    "time"
)

// worker 是一个接收信号并执行任务的协程
func worker(done chan struct{}) {
    fmt.Println("worker 等待任务信号...")
    <-done // 阻塞等待信号
    fmt.Println("任务收到，开始执行")
    time.Sleep(time.Second) // 模拟工作过程
    fmt.Println("任务完成")
    close(done) // 通知任务已完成
}

func main() {
    done := make(chan struct{})
    go worker(done)

    // 给worker发送执行信号
    time.Sleep(2 * time.Second) // 等待一段时间
    fmt.Println("主线程发送执行信号")
    done <- struct{}{} // 发送空结构体作为信号

    // 等待worker完成
    <-done
    fmt.Println("主线程收到完成信号")
}

在这个例子中，通道chan struct{}仅用于同步和通知，不需要传递任何实际数据。使用空结构体既节省内存，又能清晰地表达"这里只是一个信号，没有数据"的语义。

3.3 控制协程并发度

利用空结构体通道可以轻松实现协程池，控制最大并发数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

import (
    "fmt"
    "sync"
    "time"
)

// 使用空结构体通道限制并发数量
func main() {
    tasks := make([]int, 10) // 10个任务
    for i := range tasks {
        tasks[i] = i + 1
    }

    // 并发限制为3
    concurrencyLimit := 3
    sem := make(chan struct{}, concurrencyLimit)

    var wg sync.WaitGroup
    for _, task := range tasks {
        wg.Add(1)
        taskID := task // 创建局部变量避免闭包问题

        sem <- struct{}{} // 获取信号量，达到限制时阻塞
        go func() {
            defer wg.Done()
            defer func() { <-sem }() // 释放信号量

            // 模拟任务处理
            fmt.Printf("处理任务 %d 开始\n", taskID)
            time.Sleep(2 * time.Second)
            fmt.Printf("处理任务 %d 完成\n", taskID)
        }()
    }

    wg.Wait()
    fmt.Println("所有任务处理完毕")
}

3.4 仅包含方法的结构体

当一个类型只需要方法而不需要状态时，空结构体是理想的选择：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import "fmt"

// Logger 是一个简单的日志接口
type Logger interface {
    Log(message string)
    Error(message string)
}

// ConsoleLogger 实现了Logger接口
type ConsoleLogger struct{}

func (l ConsoleLogger) Log(message string) {
    fmt.Printf("[INFO] %s\n", message)
}

func (l ConsoleLogger) Error(message string) {
    fmt.Printf("[ERROR] %s\n", message)
}

func main() {
    var logger Logger = ConsoleLogger{}
    logger.Log("这是一条普通日志")
    logger.Error("这是一条错误日志")
}

由于ConsoleLogger不需要存储任何状态，使用空结构体可以避免不必要的内存分配。

3.5 实现单例模式

空结构体适合用于实现单例模式，特别是当单例不需要保存状态时：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package main

import (
    "fmt"
    "sync"
)

// 单例类型
type singleton struct{}

var (
    instance singleton
    once     sync.Once
)

// GetInstance 返回单例实例
func GetInstance() singleton {
    once.Do(func() {
        instance = singleton{}
    })
    return instance
}

// 单例方法
func (s singleton) DoSomething() {
    fmt.Println("单例方法被调用")
}

func main() {
    s1 := GetInstance()
    s2 := GetInstance()

    // 验证是否为相同实例
    fmt.Printf("s1: %p\n", &s1)
    fmt.Printf("s2: %p\n", &s2)

    s1.DoSomething()
}

4. 空结构体作为函数参数和返回值

空结构体也可以用作函数参数和返回值，表示不需要任何实际数据：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt"

// 使用空结构体作为参数，表示不需要输入数据
func doOperation(notUsed struct{}) string {
    return "操作完成"
}

// 使用空结构体作为返回值，表示只关心操作是否完成
func checkStatus() struct{} {
    fmt.Println("状态检查完成")
    return struct{}{}
}

func main() {
    result := doOperation(struct{}{})
    fmt.Println(result)

    _ = checkStatus() // 我们对返回值不感兴趣，只关心函数是否执行
}

5. 使用空结构体的性能比较

对比空结构体和 bool 作为 map 值的内存占用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package main

import (
    "fmt"
    "runtime"
    "unsafe"
)

func memStats() uint64 {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    return m.Alloc
}

func main() {
    // 创建足够大的数据集以观察内存差异
    const count = 10000000 // 一千万条数据

    beforeBool := memStats()
    mapBool := make(map[int]bool, count)
    for i := 0; i < count; i++ {
        mapBool[i] = true
    }
    afterBool := memStats()

    runtime.GC() // 触发GC以获得更准确的测量

    beforeEmpty := memStats()
    mapEmpty := make(map[int]struct{}, count)
    for i := 0; i < count; i++ {
        mapEmpty[i] = struct{}{}
    }
    afterEmpty := memStats()

    fmt.Printf("bool map大小：%d 字节\n", afterBool-beforeBool)
    fmt.Printf("空结构体map大小：%d 字节\n", afterEmpty-beforeEmpty)
    fmt.Printf("每个元素节省：%d 字节\n", unsafe.Sizeof(true))
    fmt.Printf("总共节省：%.2f MB\n",
        float64(unsafe.Sizeof(true)*count)/(1024*1024))
}

6. 最佳实践和注意事项

  1. 合理使用空结构体：当需要占位符而不需要存储实际数据时，优先考虑使用空结构体。
  2. 语义清晰：使用空结构体不仅仅是为了优化内存，更重要的是能够表达"这里不需要值"的语义。
  3. 避免过度优化：对于小型程序或元素数量较少的场景，使用空结构体带来的内存节省可能不明显，此时可以优先考虑代码的可读性。
  4. 用于信号通道：当使用 channel 仅作为信号通知而不传递数据时，应始终使用chan struct{}而非chan bool。
Golang
Licensed under CC BY-NC-SA 4.0
comments powered by Disqus