Go condition variable

Conditional waiting is different from mutexes , A mutex is a lock shared by different processes , Conditional waiting is that different processes each use a lock , but
yes wait() Method calls wait （ Blocking ）, Until a signal comes , Different co processes are common signals .

Wait() Block the current collaboration

func (c *Cond) Wait() {
    c.checker.check()
    t := runtime_notifyListAdd(&c.notify)  //  Waiting for the goruntine Count +1
    c.L.Unlock() //  Release lock resource 
    runtime_notifyListWait(&c.notify, t) //  Blocking , Waiting for others goruntine Wake up the 
    c.L.Lock() //  Access to resources 
}

Signa() and BroadCast()  Wake up synergy

func (c *Cond) Signal() {
    c.checker.check()
    runtime_notifyListNotifyOne(&c.notify) //  Wake up the first to be blocked goruntine
}

func (c *Cond) Broadcast() {
    c.checker.check()
    runtime_notifyListNotifyAll(&c.notify) //  Wake up all goruntine
}

 demo

package main
import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var cond sync.Cond

// producer 
func producer(out chan<- int, index int){
	for{
		cond.L.Lock()
		for len(out) == 10 {
			fmt.Println(index, "len == 10")
			cond.Wait()// Blocking   wait for 
		}
		num := rand.Intn(800)
		time.Sleep(time.Second)
		out<- num
		fmt.Println(" producer ：",index, num)

		cond.L.Unlock()
		cond.Signal()// Wake up the blocked process 
	}
}

// consumer 
func consumer(in <-chan int, index int){
	for{
		cond.L.Lock()
		for len(in) == 0 {
			fmt.Println(index, "len == 0")
			cond.Wait()// Blocking   wait for 
		}
		time.Sleep(time.Second)
		num := <-in
		fmt.Println(" consumer ：",index,num)
		cond.L.Unlock()
		cond.Signal()// Wake up the blocked process 
	}

}
func main() {
	ch := make(chan int, 10)
	rand.Seed(time.Now().UnixMilli())
	cond.L = new(sync.Mutex)

	for i:=1; i<=4; i++{
		go producer(ch, i)
	}

	for i:=1; i<=6; i++{
		go consumer(ch, i)
	}

	quit := make(chan []struct{})
	<-quit

}