go channel

//定义一个channel
c := make(chan bool)

//向channel中写入
c  <- true
//读取channel
<-c

有缓存，写入或者读出后继续往下执行;
在读的地方，如果别的地方没有写入，则阻塞在那，等有写入时才，读出，继续执行下去;
在写的地方，如果别的地方没有读就会阻塞在写的这个地方，等带别的地方读出来；不被读掉就会阻塞;
无缓存通道只有读写同时发生是才不阻塞；
向一个通道中读或者写时，必须要有别的携程接受了这个参数;
取在读前面.有缓存是异步，无缓存是同步阻塞;

package main

import (
"log"
"sync"
//"time"                //延迟用
)
//channel 是一个引用类型

func main() {
//demo1()
//demo3()
//demo4()
//demo5()
demo6()
}

//简单的迭代操作
func demo1(){
c := make(chan bool)            //双向通道
go func(){
log.Println("gogogo!")
c <- true            //向channel c中输入
close(c)            //当channel在迭代操作是，必须在某个地方关闭它，不然程序将会进入死锁
}()
//go Go()                //并发执行
//time.Sleep(2 *time.Second)        // 延迟两秒中
//<-c                    //阻塞中只有当并发执行的方法中向c中输入是这边才继续往下执行
for v := range c{            //迭代操作c
log.Println(v)
}
}
func Go() {
log.Println("gogogo!")
}

//单向通道
func demo2() {

}

//缓存:取在读前面.有缓存是异步，无缓存是同步阻塞;
//有缓存:有缓存，就会写入或者读出后继续往下执行;无缓存通道只有读写同时发生是才不阻塞；向一个通道中读或者写时，必须要有别的携程接受了这个参数;
//无缓存:在读的地方，如果别的地方没有写入，则阻塞在那，等有写入时才，读出，继续执行下去;在写的地方，如果别的地方没有读就会阻塞在写的这个地方，等带别的地方读出来；不被读掉就会阻塞;
func demo3(){
//c := make(chan bool,1) //有缓存
c := make(chan bool) //无缓存
go func(){
log.Println("123")
c <- true    //写入
}()
<- c    //读出
}

func demo4() {
c := make(chan bool,10)        //定义缓存为10
for i:=0;i< 10;i++ {
go demo4Go(c,i)
}
for i:=0;i<10;i++ {        //循环读出10次后结束
<-c
}
}

func demo4Go(c chan bool,index int){
a := 1
for i := 0; i<1000000; i++ {
a += i
}
log.Println(index,a)
c <- true            //循环一次向channel中写一次
}

//创建任务组。WaitGrpup,并发执行，使用WaitGroup实现所有进程都完成
func demo5() {
wg := sync.WaitGroup{}
wg.Add(10)        //添加十个任务
for i:=0;i< 10;i++ {
go demo5Go(&wg,i)    //wg传递为地址传递
}
wg.Wait()        //当全部任务完成后 继续执行
}
func demo5Go(wg *sync.WaitGroup,index int){
a := 1
for i := 0; i<1000000; i++ {
a += i
}
log.Println(index,a)
wg.Done()        //干掉一个任务
}

func demo6(){
c1,c2 := make(chan int),make(chan string)    //定义两个channel
o := make(chan bool)                //总channel
go func(){
for {
select {
case v,ok := <- c1:
if  !ok {
o<-true
break
}
log.Println("c1",v)
case v,ok := <-c2:
if !ok {
o<-true
break
}
log.Println("c2",v)
}
}
}()
c1 <- 1
c2 <- "hello"
c1 <- 2
c2 <- "world"
close(c1)
close(c2)

<- o
}