golang channel

ex1

package main
/*
goroutine 是由GO运行时管理的轻量级线程
go f(x,y, z) 就启动了一个goroutine， 其中f,x,y,z在当前goroutine中当即计算， f内容的执行在另外一个新goroutine中。
全部的goroutine都是运行在同一个地址空间中， 全部访问共享内存时，必须进行同步处理。
在sync包中上， 提供了同步须要的原语
*/
import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

ex2

package main


/*
Channels 就管道，就是剧导管， 你可能管道操做符进行读写, 操做符为 <-
ch <- v    // 把 v 写入管道
v := <-ch  // 从 ch 管道中读出到 v 变量中
数据的流向， 就箭头的指向。
全部 maps , slices, channels 复杂结构都须要经过make来建立
ch := make (chan int)
默认状况下， 发收都须要对端准备好了才行， 这样的前提使得goroutine同步就不须要显式的锁处理，下降了复杂度，简化的设计。

下面示例代码， 对slice的值求和。 分布式的工做在两个goroutine中。当其两个完成计算时，最终结果也计算出来了
*/

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // send sum to c
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // receive from c

    fmt.Println(x, y, x+y)
}

ex3

/*
Channels 就管道
导管经过第二个参数，是能够指定其缓存长度的
ch := make(chan int, 100)
当管道满时， 发送会阻塞
当管道空时， 接收会阻塞

修改下面的代码，能够进行测试一下
*/

package main

import (
    "fmt"
    "time"
)

// 例一、写阻塞等待
func put_chan(ch chan int, n int)  {
    for i := 0 ; i < n;  i++{
        fmt.Println("put: ", i, time.Now().UTC())
        ch <- i
    }
    close(ch)
}

func read_chan(ch chan int, quit chan int)  {
    for c := range ch{
        time.Sleep(time.Duration(time.Second * 3))
        fmt.Println(c, time.Now().UTC())
    }
    time.Sleep(time.Duration(time.Second * 3))
    quit <- 1
}
func main() {
    ch := make(chan int, 2)
    quit := make(chan int)
    go put_chan(ch, 10)
    go read_chan(ch, quit)


    fmt.Println("end", <- quit, time.Now().UTC())

}

//// 例二、读阻塞等待
//func put_chan(ch chan int, n int)  {
//  for i := 0 ; i < n;  i++{
//      time.Sleep(time.Duration(time.Second * 3))
//      ch <- i
//  }
//  time.Sleep(time.Duration(time.Second * 3))
//  close(ch)
//}
//
//func read_chan(ch chan int, quit chan int)  {
//  for c := range ch{
//      fmt.Println(c, time.Now())
//  }
//  quit <- 1
//}
//func main() {
//  ch := make(chan int, 2)
//  quit := make(chan int)
//  go put_chan(ch, 2)
//  go read_chan(ch, quit)
//
//
//  fmt.Println("end", <- quit, time.Now())
//
//}

// 例三、测试中发现，系统检测会出现死锁
//func main() {
//  ch := make(chan int, 2)
//  ch <- 1
//  ch <- 2
//  fmt.Println(<-ch)
//  fmt.Println(<-ch)
//  fmt.Println(<-ch)
//  fmt.Println("end")
//
//}

ex4

/*
Channels Range & Close 范围排列与关闭
发送者能够经过关闭通道来通知没有更多数据须要发送了。
接收者能够检测通道是否已经关闭了，经过指定第二个参数来实现，具体以下
v , ok := <- ch
当ok为false, 则通道已经关闭，没有数据了。
或者可使用循环 for i := range c 来取数据，至到通道关闭。
注意<惯例>：
   1. 应该只让发送者来关闭通道。 绝对不要让接收者来关闭。 在一个已经关闭了的通道上发数据会引起panic
   2. 通道，只在最终不要了， 须要终止的时候才来关闭之
*/

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.Println(i)
    }
}

ex5

/*
Channels  select  选择查询操做
选择查询语句， 让当前goroutine 等待多个通信操做
当没有条件知足时， select阻塞
当有  条件知足时， select执行
当有多条件知足时， select随机执行知足条件之一
*/

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:    // 写
            x, y = y, x+y
        case <-quit:    // 读
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

ex6

/*
Channels  select  选择查询操做
缺省选择， 当没有case条件知足时， 直接选择默认条件
*/

package main

import (
    "fmt"
    "time"
)

func main() {
    tick := time.Tick(100 * time.Millisecond)
    boom := time.After(500 * time.Millisecond)
    for {
        select {
        case <-tick:
            fmt.Println("tick.")
        case <-boom:
            fmt.Println("BOOM!")
            return
        default:
            fmt.Println("    .")
            time.Sleep(50 * time.Millisecond)
        }
    }
}