channel的關閉的經典場景

關閉原則

一個常用的使用Go通道的原則是不要在資料接收方或者在有多個發送者的情況下關閉通
道，

通用的原則是不要關閉已關閉的通道

錯誤關閉

	ch:=make(chan int,1)
	go func(ch chan int) {
		ch<-1
		log.Println("OK1")
		ch<-2 //阻塞1秒
		log.Println("OK2")
		ch<-3 //報錯 因為下面把管道關閉了
	}(ch)

	go func(ch chan int) {
		log.Println("進入讀")
		time.Sleep(time.Second)
		log.Println(<-ch)
		close(ch)
	}(ch)
	time.Sleep(time.Hour)

優雅關閉

do once代表只能執行一次，防止重復關閉

type MyChannel struct {
	C chan int
	once sync.Once
}

func (myChannel MyChannel) SafeClose(){
	myChannel.once.Do(func() {
		close(myChannel.C)
	}) //once代表只執行一次
}

func main() {
	write:=MyChannel{C:make(chan int)}
	go func() {write.C<-1;write.SafeClose()}()
	go func() {log.Println(<-write.C)}()

	time.Sleep(time.Hour)
}

關閉情況

1、多個接收者，一個發送者

這里只有一個發送者，當value=https://www.cnblogs.com/biningooginind/p/0時，這個發送者關閉管道，這里只有一個寫行程，所以不用擔心重復關閉問題，寫行程可以直接關閉管道

這時，所有的接受者for-range會全部結束

這里的結束信號由寫者發出

func Write(dataCh chan int){
	for{
		if value:=rand.Intn(1000);value!=0{
			time.Sleep(time.Microsecond*500)
			dataCh<-value
		}else{
			close(dataCh)
		}
	}
}
const NumReceivers  =100
var wg=sync.WaitGroup{}

//多個接收者
func Readers(dataCh <-chan int){
	for i:=0;i<NumReceivers;i++{
		go func() {
			defer wg.Done()
			for value:=range dataCh{
				log.Println(value)
			}
		}()
	}
}

func main() {
	rand.Seed(time.Now().UnixNano())
	wg.Add(NumReceivers)


	dataCh:=make(chan int)

	go Write(dataCh)
	Readers(dataCh)

	wg.Wait()


}

2、【變種】多個接收者，一個發送者，但是關閉信號是由第三方發送

這里用了兩個關閉信號

closing：用來通知寫攜程可以停止寫了

closed：用來表示closing信號已經由一個第三方發出過了，后面的第三方可以不用再發了

package main

import (
	"log"
	"math/rand"
	"sync"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())

	const NumReceivers  = 100
	const NumThirdParties  = 100 //第三方

	wg4:=sync.WaitGroup{}
	wg4.Add(NumReceivers)
	dataCh2:=make(chan int)
	closing:=make(chan bool) //通知寫行程 關閉的信號
	closed:=make(chan bool) //通道已經關閉的 信號

	stop:= func() {
		select {
		case closing<-true: //通知關閉
			<-closed   //有一個寫行程收到通知 則結束
		case <-closed: //如果已經關閉 則執行這一句  所以多次呼叫stop是安全非阻塞的
		}
	}

	//多個第三方攜程
	for i:=0;i<NumThirdParties;i++{
		go func() {
			time.Sleep(time.Second*time.Duration(rand.Intn(100)))
			stop()
		}()
	}

	//發送者 1
	go func() {

		defer func() {
			close(closed) //通知第三方 已經關閉了
			close(dataCh2) //關閉資料通道
		}()

		for{

			select {
			case <-closing:
				return
			default:
			}

			select {
			case <-closing: //收到第三方的關閉請求
				return
			case dataCh2<-rand.Intn(100000):
			}
		}
	}()


	for i:=0;i<NumReceivers;i++{
		go func() {

			defer wg4.Done()

			for value:=range dataCh2{
				log.Println(value)
			}

		}()
	}

	wg4.Wait()
}

3、多個發送者，一個接收者

這里有10000個發送者，為了遵循 管道不能被讀者關閉的原則，于是這里又建立了一個stopCh非緩沖管道，目的只是為了通知多個發送者，可以不用發送了，發送者先檢查有沒有關閉信號，然后再發送，這里用了兩次select，來檢查 ，

同時注意，為了防止重復關閉管道，這里沒有讓寫行程關閉dataCh，當所有讀寫行程都不再參考dataCh的時候，就會被gc

這里的關閉信號由讀者發出

const NumSenders  = 10000
var wg2  = sync.WaitGroup{}
var dataCh = make(chan int)
var stopCh = make(chan bool)

func Sender(){
	for i:=0;i<NumSenders;i++{

		go func() {

			select {
			case <-stopCh: //通道關閉后直接執行這個
				return
			default:
			}

			select {
			case <-stopCh:  //當通道被關閉 則直接執行這個
				return  //直接回傳
			case dataCh<-rand.Intn(1000):
			}



		}()
	}
}


func Receive(){
	defer wg2.Done()
	for value:=range dataCh{
		log.Println(value)
		if value=https://www.cnblogs.com/biningooginind/p/=0{
			close(stopCh)
			return
		}
	}
}

func main() {
	wg2.Add(1)
	rand.Seed(time.Now().UnixNano())
	go Sender()
	go Receive()

	wg2.Wait()
}

4、多個接收者和多個發送者

這種情況比較復雜，必須叫一個中間人來通知雙方，當讀寫行程需要關閉，通過toStop管道通知中間人，中間人收到通知然后關閉stopCh2管道，這個管道是讓讀寫行程結束讀寫的信號，

toStop的容量必須設定成>=1 如果設定成非緩沖管道，那么如果中間人沒有準備好，要發出結束信號時會阻塞，就會轉到default,從而讓結束信號丟失，

這里的結束信號讀寫行程都可以發出

var NumSends = 100
var NumRecives = 50
var wg3 = sync.WaitGroup{}

func main() {
	rand.Seed(time.Now().UnixNano())
	wg3.Add(NumRecives)
	dataCh2 := make(chan int)
	stopCh2 := make(chan bool)
	toStop := make(chan bool, 1) //通知中間者可以關閉了 至少為1

	//中間人
	go func() {
		_ = <-toStop
		close(stopCh2)
	}()

	//發送者
	for i := 0; i < NumSends; i++ {
		go func() {
			for {
				v := rand.Intn(1000)
				if v == 0 { //寫行程通知關閉
					select {
					case toStop <- true:
						dataCh2 <- v
						log.Println("===========================", 0, "-")
					default:
					}
					return
				}
				//嘗試關閉
				select {
				case <-stopCh2:
					return
				default:
				}

				select {
				case <-stopCh2:
					return
				case dataCh2 <- v:
					log.Println(v)
				}

			}
		}()
	}
    
//接收者
	for i := 0; i < NumRecives; i++ {
		go func() {
			defer wg3.Done()
			for {
				select {
				case <-stopCh2:
					return
				default:
				}

				select {
				case <-stopCh2:
					return
				case val := <-dataCh2:
					log.Println(val)
					if val == 888 { //讀行程通知關閉
						select {
						case toStop <- true:
							log.Println("==========================", 888, "-")
						default:
						}
						return
					}
				}

			}
		}()
	}

	wg3.Wait()

}

標籤：Go

上一篇：channel通道常見使用場景

下一篇：帶你入門Go的訊息佇列NSQ