var ch chan int //管道的聲明
ch = make(chan int, 8) //管道的初始化，環(huán)形隊列里可容納8個int
ch <- 1                //往管道里寫入(send)數(shù)據(jù)
ch <- 2
ch <- 3
ch <- 4
ch <- 5
v := <-ch //從管道里取走(recv)數(shù)據(jù)
fmt.Println(v)
v = <-ch
fmt.Println(v)

    var ch1 chan int   // 聲明一個傳遞整型的通道
    var ch2 chan bool  // 聲明一個傳遞布爾型的通道
    var ch3 chan []int // 聲明一個傳遞int切片的通道    

var ch chan int
fmt.Println(ch) // <nil>

ch4 := make(chan int)
ch5 := make(chan bool)
ch6 := make(chan []int)    

ch := make(chan int) 

ch <- 10 // 把10發(fā)送到ch中 

x := <- ch // 從ch中接收值并賦值給變量x
<-ch       // 從ch中接收值，忽略結果   

close(ch) 

func main() {
    ch := make(chan int)
    ch <- 10
    fmt.Println("發(fā)送成功")
}   

func recv(c chan int) {
    ret := <-c
    fmt.Println("接收成功", ret)
}
func main() {
    ch := make(chan int)
    go recv(ch) // 啟用goroutine從通道接收值
    ch <- 10
    fmt.Println("發(fā)送成功")
}   

func main() {
    ch := make(chan int, 1) // 創(chuàng)建一個容量為1的有緩沖區(qū)通道
    ch <- 10
    fmt.Println("發(fā)送成功")
}   

package main
import "fmt"
func main() {
    c := make(chan int)
    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        close(c)
    }()
    for {
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
    }
    fmt.Println("main結束")
}

// channel 練習
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    // 開啟goroutine將0~100的數(shù)發(fā)送到ch1中
    go func() {
        for i := 0; i < 100; i++ {
            ch1 <- i
        }
        close(ch1)
    }()
    // 開啟goroutine從ch1中接收值，并將該值的平方發(fā)送到ch2中
    go func() {
        for {
            i, ok := <-ch1 // 通道關閉后再取值ok=false
            if !ok {
                break
            }
            ch2 <- i * i
        }
        close(ch2)
    }()
    // 在主goroutine中從ch2中接收值打印
    for i := range ch2 { // 通道關閉后會退出for range循環(huán)
        fmt.Println(i)
    }
}   

func counter(out chan<- int) {
    for i := 0; i < 100; i++ {
        out <- i
    }
    close(out)
}
func squarer(out chan<- int, in <-chan int) {
    for i := range in {
        out <- i * i
    }
    close(out)
}
func printer(in <-chan int) {
    for i := range in {
        fmt.Println(i)
    }
}
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go counter(ch1)
    go squarer(ch2, ch1)
    printer(ch2)
}   

read_only := make (<-chan int)   //定義只讀的channel
write_only := make (chan<- int)   //定義只寫的channel

//只能向channel里寫數(shù)據(jù) 
func send(c chan<- int) { 
    c <- 1 
} 
//只能取channel中的數(shù)據(jù) 
func recv(c <-chan int) {
	_ = <-c
}
//返回一個只讀channel
func (c *Context) Done() <-chan struct{} {
    return nil
}

close(ch) //遍歷前必須先關閉管道，禁止再寫入元素
//遍歷管道里剩下的元素
for ele := range ch {
    fmt.Println(ele)
}

asynChann := make(chan int, 8)

syncChann := make(chan int)

sc := make(chan struct{})
sc <- struct{}{}

package main
import (
	"fmt"
	"time"
)
func main() {
	ch := make(chan struct{}, 1)
	ch <- struct{}{} //有1個緩沖可以用，無需阻塞，可以立即執(zhí)行
	go func() {      //子協(xié)程1
		time.Sleep(5 * time.Second) //sleep一個很長的時間
		<-ch                        //如果把本行代碼注釋掉，main協(xié)程5秒鐘后會報fatal error
		fmt.Println("sub routine 1 over")
	}()
	ch <- struct{}{} //由于子協(xié)程1已經(jīng)啟動，寄希望于子協(xié)程1幫自己解除阻塞，所以會一直等子協(xié)程1執(zhí)行結束。如果子協(xié)程1執(zhí)行結束后沒幫自己解除阻塞，則希望完全破滅，報出deadlock
	fmt.Println("send to channel in main routine")
	go func() { //子協(xié)程2
		time.Sleep(2 * time.Second)
		ch <- struct{}{} //channel已滿，子協(xié)程2會一直阻塞在這一行
		fmt.Println("sub routine 2 over")
	}()
	time.Sleep(3 * time.Second)
	fmt.Println("main routine exit")
}

package main
import (
	"fmt"
	"time"
)
var cloch = make(chan int, 1)
var cloch2 = make(chan int, 1)
func traverseChannel() {
	for ele := range cloch {
		fmt.Printf("receive %d\n", ele)
	}
	fmt.Println()
}
func traverseChannel2() {
	for {
		if ele, ok := <-cloch2; ok { //ok==true代表管道還沒有close
			fmt.Printf("receive %d\n", ele)
		} else { //管道關閉后，讀操作會立即返回“0值”
			fmt.Printf("channel have been closed, receive %d\n", ele)
			break
		}
	}
}
func main() {
	cloch <- 1
	close(cloch)
	traverseChannel() //如果不close就直接通過range遍歷管道，會發(fā)生fatal error: all goroutines are asleep - deadlock!
	fmt.Println("==================")
	go traverseChannel2()
	cloch2 <- 1
	close(cloch2)
	time.Sleep(10 * time.Millisecond)
}

package main
import (
	"fmt"
	"time"
)
func upstream(ch chan struct{}) {
	time.Sleep(15 * time.Millisecond)
	fmt.Println("一個上游協(xié)程執(zhí)行結束")
	ch <- struct{}{}
}
func downstream(ch chan struct{}) {
	<-ch
	fmt.Println("下游協(xié)程開始執(zhí)行")
}
func main() {
	upstreamNum := 4   //上游協(xié)程的數(shù)量
	downstreamNum := 5 //下游協(xié)程的數(shù)量
	upstreamCh := make(chan struct{}, upstreamNum)
	downstreamCh := make(chan struct{}, downstreamNum)
	//啟動上游協(xié)程和下游協(xié)程，實際下游協(xié)程會先阻塞
	for i := 0; i < upstreamNum; i++ {
		go upstream(upstreamCh)
	}
	for i := 0; i < downstreamNum; i++ {
		go downstream(downstreamCh)
	}
	//同步點
	for i := 0; i < upstreamNum; i++ {
		<-upstreamCh
	}
	//通過管道讓下游協(xié)程開始執(zhí)行
	for i := 0; i < downstreamNum; i++ {
		downstreamCh <- struct{}{}
	}
	time.Sleep(10 * time.Millisecond) //等下游協(xié)程執(zhí)行結束
}