Go语言空结构体详解

var a struct{}

type empty struct{}
var e empty

// 定义一个非空结构体
type User struct {
    name string
}

func main() {
 
  // 两个非空结构体的变量地址不同
  var user1 User
    var user2 User
    fmt.Printf("%p \n", &user1) // 0xc000318670
    fmt.Printf("%p \n", &user2) // 0xc000318680
  
  // 定义两个空结构体，地址相同
    var first struct{}
    var second struct{}
    fmt.Printf("%p \n", &first)    // 0x1ca15f0 
    fmt.Printf("%p \n", &second)   // 0x1ca15f0 
}

// 非空结构体
type NonEmptyUser struct {
    name string
}

// 空结构体
type EmptyUser struct{}

// 打印非空结构体参数地址
func testNonEmptyUser(user NonEmptyUser) {
    fmt.Printf("%p \n", &user)
}

// 打印空结构体参数地址
func testEmptyUser(user EmptyUser) {
    fmt.Printf("%p \n", &user)
}


func main() {
  
    // 两个非空结构体的变量地址不同
    var user1 NonEmptyUser
    fmt.Printf("%p \n", &user1) // 0xc0001986c0
    testNonEmptyUser(user1)            // 0xc0001986d0

  
    // 两个空结构体变量的地址相同
    var user2 EmptyUser
    fmt.Printf("%p \n", &user2) // 0x1ca25f0
    testEmptyUser(user2)                // 0x1ca25f0
  
}

type EmptyUser struct{}

func main() {
    var i int
    var s string
    var m []string
    var u EmptyUser
  
    fmt.Println(unsafe.Sizeof(i)) // 8
    fmt.Println(unsafe.Sizeof(s)) // 16
    fmt.Println(unsafe.Sizeof(m)) // 24
    fmt.Println(unsafe.Sizeof(u)) // 0
}

// 空结构体的组合
type EmptyUser struct {
    name struct{}
    age  struct{}
}

func main() {
    
    var u EmptyUser

    fmt.Println(unsafe.Sizeof(u)) // 0
}

// base address for all 0-byte allocations
var zerobase uintptr

// 创建新的对象时，调用 mallocgc 分配内存
func newobject(typ *_type) unsafe.Pointer {
    return mallocgc(typ.size, typ, true)
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if gcphase == _GCmarktermination {
        throw("mallocgc called with gcphase == _GCmarktermination")
    }

    if size == 0 {
        return unsafe.Pointer(&zerobase)
    }
    ......
}

// 定义了一个保存 string 类型的 Set集合
type Set map[string]struct{}

// 添加一个元素
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 NewSet() Set {
    s := make(Set)
    return s
}

// 测试使用
func main() {
    set := NewSet()
    set.Add("hello")
    set.Add("world")
    fmt.Println(set.Contains("hello"))

    set.Remove("hello")
    fmt.Println(set.Contains("hello"))
}

func doTask1(ch chan struct{}) {
    time.Sleep(time.Second)
    fmt.Println("do task1")
    ch <- struct{}{}
}

func doTask2(ch chan struct{}) {
    time.Sleep(time.Second * 2)
    fmt.Println("do task2")
    ch <- struct{}{}
}

func main() {

    ch1 := make(chan struct{})
    ch2 := make(chan struct{})
    go doTask1(ch1)
    go doTask2(ch2)

    for {
        select {
        case <-ch1:
            fmt.Println("task1 done")
        case <-ch2:
            fmt.Println("task2 done")
        case <-time.After(time.Second * 5):
            fmt.Println("after 5 seconds")
            return
        }
    }
}