Go语言空结构体（struct{}）详解与实战应用

沈亦白

发布时间：2026-10-16| 6人浏览过

原创

Go语言中的空结构体（struct{}）不包含任何字段，占用0字节内存且所有实例共享同一地址。本文解析其底层原理，并详细介绍其在节省内存的集合Set实现及Channel信号传递中的最佳实践，帮助开发者优化资源使用。

什么是空结构体

在 Go 语言开发中，结构体通常用于包含多个字段的对象定义，但还有一种特殊的结构体——空结构体（Empty Struct），它不包含任何字段。可以通过原生方式或类型别名来定义：

// 原生定义
var a struct{}

// 类型别名
type empty struct{}
var e empty

特点分析

地址相同

与普通结构体不同，空结构体的变量无论创建多少个，它们在内存中的地址都是相同的。这是因为编译器对零大小对象进行了特殊处理。

常规内存分配对比

非空结构体每次实例化都会分配不同的内存地址，而空结构体则复用同一地址：

func main() {
	// 非空结构体地址不同
	type User struct { name string }
	var user1, user2 User
	fmt.Printf("%p\n", &user1) // 例如: 0xc000318670
	fmt.Printf("%p\n", &user2) // 例如: 0xc000318680

	// 空结构体地址相同
	var first, second struct{}
	fmt.Printf("%p\n", &first)   // 0x1ca15f0
	fmt.Printf("%p\n", &second)  // 0x1ca15f0
}

函数传参测试

将结构体作为参数传递给函数时，非空结构体会发生值拷贝，导致函数内指针地址改变；而空结构体由于地址固定，传入前后的指针地址保持一致：

func testEmptyUser(user struct{}) {
	fmt.Printf("%p\n", &user)
}

func main() {
	var u struct{}
	fmt.Printf("%p\n", &u)           // 0x1ca25f0
	testEmptyUser(u)               // 0x1ca25f0 (地址一致)
}

大小为0

使用 unsafe.Sizeof 可以验证，空结构体占用的内存空间为 0 字节。即使组合多个空结构体或嵌套其他空类型，总大小依然为 0。

func main() {
	type EmptyUser struct{}
	
	// 基础类型比较
	fmt.Println(unsafe.Sizeof(int(0)))       // 8
	fmt.Println(unsafe.Sizeof(string("")))   // 16
	fmt.Println(unsafe.Sizeof([]string{}))   // 24
	
	// 空结构体大小为0
	fmt.Println(unsafe.Sizeof(EmptyUser{}))  // 0
	
	// 组合后仍为0
	type Nested struct {
		name struct{}
		age  struct{}
	}
	fmt.Println(unsafe.Sizeof(Nested{}))     // 0
}

原理解析

在 Go 源码（src/runtime/malloc.go）中，当通过 newobject 分配内存时，会调用 mallocgc。如果检测到类型大小 size == 0，它会直接返回一个全局变量 zerobase 的地址，而不是真正的堆内存。

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
	if size == 0 {
		return unsafe.Pointer(&zerobase)
	}
	// ... 正常内存分配逻辑 ...
}

这一机制解释了为什么所有空结构体都指向同一地址，且在内存占用上完全忽略不计。

使用场景

由于空结构体不消耗内存且具有语义占位特性，主要适用于以下场景：

1. 实现集合（Set）

Go 标准库没有内置 Set 类型，但可以利用 Map 的特性来模拟。Map 的 Key 是唯一的，只需将 Value 设为空结构体，即可在不增加内存开销的前提下实现去重集合。

// 定义 Set 类型
type Set map[string]struct{}

// 初始化
func NewSet() Set {
	return make(Set)
}

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

// 移除元素
func (s Set) Remove(key string) {
	delete(s, key)
}

// 判断是否存在
func (s Set) Contains(key string) bool {
	_, ok := s[key]
	return ok
}

func main() {
	set := NewSet()
	set.Add("hello")
	set.Add("world")
	fmt.Println(set.Contains("hello")) // true
	set.Remove("hello")
	fmt.Println(set.Contains("hello")) // false
}

2. Channel 信号传输

在使用 channel 进行并发控制时，往往只需要传达“完成”或“触发”的信号，并不关心传输的数据内容。此时使用 chan struct{} 是最优选择，因为它比 chan bool 或 chan int 更节省带宽和内存。

func doTask(ch chan struct{}) {
	time.Sleep(time.Second)
	ch <- struct{}{} // 发送信号
}

func main() {
	ch := make(chan struct{})
	go doTask(ch)
	
	<-ch // 阻塞直到收到信号
	fmt.Println("任务完成")
}

在复杂的并发模型中（如 select 等待多个任务完成或超时），空结构体 channel 能高效管理流程，避免无意义的数值传输。