go语言-空结构体/ chan struct{}

文章目录

空结构体 struct{}
chan struct{}
- 常用用法
- 带缓冲的chan struct{}数据读写

空结构体 struct{}

空结构体的宽度是0，占用了0字节的内存空间。

var s struct{}
fmt.Println(unsafe.Sizeof(s)) // prints 0

由于空结构体占用0字节，那么空结构体也不需要填充字节。所以空结构体组成的组合数据类型也不会占用内存空间。

 type S struct {A struct{}B struct{}}var s Sfmt.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.FullNodeepp gen.WinningPoStProverlk       sync.Mutexaddress  address.Addressstop     chan struct{}stopping chan struct{}waitFunc waitFunclastWork *MiningBaseminedBlockHeights *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.stoppingclose(m.stop)select {case <-stopping:return nilcase <-ctx.Done():return ctx.Err()}
}

使用场景
首先事件通知，可以通过写入通知其他协程，但是只能通知一个。

channel := make(chan struct{})
go func() {// ... do somethingchannel <- 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:returndefault:// .. do something}}
}

带缓冲的chan struct{}数据读写

另外也可以定义带缓冲的channel

package mainimport ("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 := <-chlog.Println("main() 333", a);b  = <-chlog.Println("main() 444", b);c := <-chlog.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被关闭了或者为空。