一、关于struct {}
struct是Go中的关键字，用于定义结构类型
type User struct {
Name string
Age int
}
struct {} ：表示struct类型
struct {} 是一种普通数据类型，一个无元素的结构体类型，通常在没有信息存储时使用。
优点是大小为0，不需要内存来存储struct {}类型的值。
struct {} {}：表示struct类型的值，该值也是空。
struct {} {}是一个复合字面量，它构造了一个struct {}类型的值，该值也是空。
var set map[string]struct{}
set = make(map[string]struct{})
// Add some values to the set:
set["red"] = struct{}{}
set["blue"] = struct{}{}
// Check if a value is in the map:
_, ok := set["red"]
fmt.Println("Is red in the map?", ok)
_, ok = set["green"]
fmt.Println("Is green in the map?", ok)
输出内容
Is red in the map? true Is green in the map? false
空结构体的宽度是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
二、chan struct{}
通过消息来共享数据是golang的一种设计哲学，channel则是这种哲理的体现。
golang中的空结构体 channel := make(chan struct{})
-
省内存，尤其在事件通信的时候。
-
struct零值就是本身，读取close的channel返回零值
1、通常struct{}类型channel的用法是使用同步
注意，channel对象一定要make出来才能使用
一般不需要往channel里面写数据，只有读等待，而读等待会在channel被关闭的时候返回。
package main
import (
"time"
"log"
)
var ch chan struct{} = make(chan struct{})
func foo() {
log.Println("foo start");
time.Sleep(3 * time.Second)
log.Println("foo close chan");
close(ch)
log.Println("foo end");
}
func main() {
log.Println("main start");
go foo()
log.Println("main wait chan");
<-ch
log.Println("main end");
}
运行结果
2022/05/28 19:34:44 main start 2022/05/28 19:34:44 main wait chan 2022/05/28 19:34:44 foo start 2022/05/28 19:34:47 foo close chan 2022/05/28 19:34:47 foo end 2022/05/28 19:34:47 main end
如果一开始就往 元素类型为 struct{} 的 chan 中写元素，则 main 中会立马收到信息
package main
import (
"time"
"log"
)
var ch chan struct{} = make(chan struct{})
func foo() {
log.Println("foo start");
ch <- struct{}{}
time.Sleep(3 * time.Second)
log.Println("foo close chan");
close(ch)
log.Println("foo end");
}
func main() {
log.Println("main start");
go foo()
log.Println("main wait chan");
ret, ok := <-ch
if ok {
log.Println("main recv info : ", ret);
} else {
log.Println("main chan has closed");
}
log.Println("main end");
}
运行结果
2022/05/28 19:35:41 main start
2022/05/28 19:35:41 main wait chan
2022/05/28 19:35:41 foo start
2022/05/28 19:35:41 main recv info : {}
2022/05/28 19:35:41 main end
2、比较经典的例子就是用于stopChan作为停止channel通知所有协程
type Server struct {
serverStopChan chan struct{}
stopWg sync.WaitGroup
}
func (s *Server) Stop() {
if s.serverStopChan == nil {
panic("gorpc.Server: server must be started before stopping it")
}
close(s.serverStopChan)
s.stopWg.Wait()
s.serverStopChan = nil
}
func serverHandler(s *Server){
for {
select {
case <-s.serverStopChan:
return
default:
// .. do something
}
}
}
3、带缓冲的chan struct{}数据读写
另外也可以定义带缓冲的channel
package main
import (
"time"
"log"
)
var ch chan struct{} = make(chan struct{}, 2)
func foo() {
ch <- struct{}{}
log.Println("foo() 000");
ch <- struct{}{}
log.Println("foo() 111");
time.Sleep(5 * time.Second)
log.Println("foo() 222");
close(ch)
log.Println("foo() 333");
}
func main() {
var b struct{}
log.Println("main() 111");
go foo()
log.Println("main() 222");
a := <-ch
log.Println("main() 333", a);
b = <-ch
log.Println("main() 444", b);
c := <-ch
log.Println("main() 555", c);
}
<-ch用来从channel ch中接收数据，这个表达式会一直被block,直到有数据可以接收。
从一个nil channel中接收数据会一直被block。（往nil channel中发送数据会一致被阻塞着。）
从一个被close的channel中接收数据不会被阻塞，而是立即返回，接收完已发送的数据后会返回元素类型的零值(zero value)。
如前所述，你可以使用一个额外的返回参数来检查channel是否关闭。
x, ok := <-ch x, ok = <-ch var x, ok = <-ch
如果OK 是false，表明接收的x是产生的零值，这个channel被关闭了或者为空。