- 方式1
// producer 生产者
func producer(c chan<- int) {
defer close(c)
for i := 0; i < 10; i++ {
c <- i + 1
time.Sleep(time.Millisecond * 100)
}
}
// consumer 消费者
func consumer(c <-chan int) {
for item := range c {
fmt.Println(item)
}
}
func main() {
c := make(chan int)
go producer(c)
consumer(c)
}
- 方式2
// producer 生产者
func producer(c chan<- int) {
defer close(c)
for i := 0; i < 10; i++ {
c <- i + 1
time.Sleep(time.Millisecond * 100)
}
}
// consumer 消费者
func consumer(c <-chan int, o chan<- struct{}) {
for item := range c {
fmt.Println(item)
}
o <- struct{}{}
}
func main() {
c := make(chan int)
over := make(chan struct{}) // 开关
go producer(c)
go consumer(c, over)
<-over
}
方式2将消费者和生产者都改为协程执行，然后通过一个开关来阻塞主程，当消费者执行完成后塞入一个空结构体，主程收到后结束阻塞
- 方式3
// producer 生产者
func producer(c chan<- int) {
defer close(c)
for i := 0; i < 10; i++ {
c <- i + 1
time.Sleep(time.Millisecond * 100)
}
}
// consumer 消费者
func consumer(c <-chan int) (result chan struct{}) {
result = make(chan struct{})
go func() {
defer func() {
result <- struct{}{}
}()
for item := range c {
fmt.Println(item)
}
}()
return
}
func main() {
c := make(chan int)
go producer(c)
res := consumer(c)
<-res
}
方式3将2的开关改写到消费者内部，更加通俗易懂
