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"
)
// 例1、写阻塞等待
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())
}
//// 例2、读阻塞等待
//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())
//
//}
// 例3、测试中发现，系统检测会出现死锁
//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)
}
}
}
