空结构体 struct{}
空结构体的宽度是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返回零值
常用用法
通常struct{}类型channel的用法是使用同步,一般不需要往channel里面写数据,只有读等待,而读等待会在channel被关闭的时候返回。
type Miner struct {
api api.FullNode
epp gen.WinningPoStProver
lk sync.Mutex
address address.Address
stop chan struct{}
stopping chan struct{}
waitFunc waitFunc
lastWork *MiningBase
minedBlockHeights *lru.ARCCache
}
stop 它是一个管道chan,内部的数据类型是struct{}。
单独拿struct{}来说,我们熟悉type Name struct{a int, b bool}这样去定义一个结构体的类型,其实struct{…}就是定义结构体,和map[string]int这种定义是一样的,type只是给它取了一个别名。 总结: 实际上struct{}就是一种普通数据类型,只是没有具体的值而已。
注意,channel对象一定要make出来才能使用。, 如下,make后赋值给m
func (m *Miner) Start(ctx context.Context) error {
m.lk.Lock()
defer m.lk.Unlock()
if m.stop != nil {
return fmt.Errorf("miner already started")
}
m.stop = make(chan struct{})
go m.mine(context.TODO())
return nil
}
func (m *Miner) Stop(ctx context.Context) error {
m.lk.Lock()
defer m.lk.Unlock()
m.stopping = make(chan struct{})
stopping := m.stopping
close(m.stop)
select {
case <-stopping:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
使用场景
首先事件通知,可以通过写入 通知其他协程,但是只能通知一个。
channel := make(chan struct{})
go func() {
// ... do something
channel <- struct{}{}
}()
fmt.Println(<-channel)
和close进行配合,通知所有相关协程。
在读入被close的channel返回零值,正常的协程是读取不到这个close的。
close之后,所有协程都可以读到。
比较经典的例子就是用于stopChan作为停止channel通知所有协程。
在下面的例子中 我们可以通过s.Stop()通知所有的serverHandler协程停止工作,并且等待他们正常退出。
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
}
}
}
带缓冲的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被关闭了或者为空。