var quit chan int = make(chan int)func loop() {for i := 0; i < 10; i++ {fmt.Printf("%d ", i)}quit <- 0
}func main() {// 开两个goroutine跑函数loop, loop函数负责打印10个数go loop()go loop()for i := 0; i < 2; i++ {<- quit}
}

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

package mainimport "fmt"
import "time"var quit chan intfunc foo(id int) {fmt.Println(id)time.Sleep(time.Second) // 停顿一秒quit <- 0 // 发消息：我执行完啦！
}func main() {count := 1000quit = make(chan int, count) // 缓冲1000个数据for i := 0; i < count; i++ { //开1000个goroutinego foo(i)}for i :=0 ; i < count; i++ { // 等待所有完成消息发送完毕。<- quit}
}

go build test.go
time ./test
./test  0.01s user 0.01s system 1% cpu 1.016 total

import ("fmt""runtime"
)var quit chan int = make(chan int)func loop() {for i := 0; i < 100; i++ { //为了观察，跑多些fmt.Printf("%d ", i)}quit <- 0
}func main() {runtime.GOMAXPROCS(2) // 最多使用2个核go loop()go loop()for i := 0; i < 2; i++ {<- quit}
}

func loop() {for i := 0; i < 10; i++ {        runtime.Gosched() // 显式地让出CPU时间给其他goroutine
        fmt.Printf("%d ", i)}quit <- 0
}func main() {go loop()go loop()for i := 0; i < 2; i++ {<- quit}
}

0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

package mainimport ("fmt"
)func say(s string) {for i := 0; i < 5; i++ {fmt.Println(s)}
}func main() {go say("world") //开一个新的Goroutines执行for {}
}

package mainimport ("fmt""runtime"
)var quit chan int = make(chan int)func loop(id int) { // id: 该goroutine的标号for i := 0; i < 10; i++ { //打印10次该goroutine的标号fmt.Printf("%d ", id)}quit <- 0
}func main() {runtime.GOMAXPROCS(2) // 最多同时使用2个核for i := 0; i < 3; i++ { //开三个goroutinego loop(i)}for i := 0; i < 3; i++ {<- quit}
}

0 0 0 0 0 1 1 0 0 1 0 0 1 0 1 2 1 2 1 2 1 2 1 2 1 2 2 2 2 2
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2
0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 1 0 1 2 1 2 1 2 2 2 2 2 2 2 2
0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 2 0 2 0 2 2 2 2 2 2 2 2
0 0 0 0 0 0 0 1 0 0 1 0 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 2 2

func xrange() chan int{ // xrange用来生成自增的整数var ch chan int = make(chan int)go func() { // 开出一个goroutinefor i := 0; ; i++ {ch <- i  // 直到信道索要数据，才把i添加进信道}}()return ch
}func main() {generator := xrange()for i:=0; i < 1000; i++ {  // 我们生成1000个自增的整数！fmt.Println(<-generator)}
}

func get_notification(user string) chan string{/*
    * 此处可以查询数据库获取新消息等等..
    */notifications := make(chan string)go func() { // 悬挂一个信道出去notifications <- fmt.Sprintf("Hi %s, welcome to weibo.com!", user)}()return notifications
}func main() {jack := get_notification("jack") //  获取jack的消息joe := get_notification("joe") // 获取joe的消息// 获取消息的返回fmt.Println(<-jack)fmt.Println(<-joe)
}

func do_stuff(x int) int { // 一个比较耗时的事情，比如计算time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond) //模拟计算return 100 - x // 假如100-x是一个很费时的计算
}func branch(x int) chan int{ // 每个分支开出一个goroutine做计算并把计算结果流入各自信道ch := make(chan int)go func() {ch <- do_stuff(x)}()return ch
}func fanIn(chs... chan int) chan int {ch := make(chan int)for _, c := range chs {// 注意此处明确传值go func(c chan int) {ch <- <- c}(c) // 复合}return ch
}func main() {result := fanIn(branch(1), branch(2), branch(3))for i := 0; i < 3; i++ {fmt.Println(<-result)}
}

func foo(i int) chan int {c := make(chan int)go func () { c <- i }()return c
}func main() {c1, c2, c3 := foo(1), foo(2), foo(3)c := make(chan int)go func() { // 开一个goroutine监视各个信道数据输出并收集数据到信道cfor {select { // 监视c1, c2, c3的流出，并全部流入信道ccase v1 := <- c1: c <- v1case v2 := <- c2: c <- v2case v3 := <- c3: c <- v3}}}()// 阻塞主线，取出信道c的数据for i := 0; i < 3; i++ {fmt.Println(<-c) // 从打印来看我们的数据输出并不是严格的1,2,3顺序}
}

func fanIn(branches ... chan int) chan int {c := make(chan int)go func() {for i := 0 ; i < len(branches); i++ { //select会尝试着依次取出各个信道的数据select {case v1 := <- branches[i]: c <- v1}}}()return c
}

timeout := time.After(1 * time.Second) // timeout 是一个计时信道, 如果达到时间了，就会发一个信号出来for is_timeout := false; !is_timeout; {select { // 监视信道c1, c2, c3, timeout信道的数据流出case v1 := <- c1: fmt.Printf("received %d from c1", v1)case v2 := <- c2: fmt.Printf("received %d from c2", v2)case v3 := <- c3: fmt.Printf("received %d from c3", v3)case <- timeout: is_timeout = true // 超时}
}

func main() {c, quit := make(chan int), make(chan int)go func() {c <- 2  // 添加数据quit <- 1 // 发送完成信号} ()for is_quit := false; !is_quit; {select { // 监视信道c的数据流出case v := <-c: fmt.Printf("received %d from c", v)case <-quit: is_quit = true // quit信道有输出，关闭for循环}}
}

/*
 *  利用信道菊花链筛法求某一个整数范围的素数
 *  筛法求素数的基本思想是：把从1开始的、某一范围内的正整数从小到大顺序排列，
 *  1不是素数，首先把它筛掉。剩下的数中选择最小的数是素数，然后去掉它的倍数。
 *  依次类推，直到筛子为空时结束
 */
package mainimport "fmt"func xrange() chan int{ // 从2开始自增的整数生成器var ch chan int = make(chan int)go func() { // 开出一个goroutinefor i := 2; ; i++ {ch <- i  // 直到信道索要数据，才把i添加进信道}}()return ch
}func filter(in chan int, number int) chan int {// 输入一个整数队列，筛出是number倍数的, 不是number的倍数的放入输出队列// in:  输入队列out := make(chan int)go func() {for {i := <- in // 从输入中取一个if i % number != 0 {out <- i // 放入输出信道}}}()return out
}func main() {const max = 100 // 找出100以内的所有素数nums := xrange() // 初始化一个整数生成器number := <-nums  // 从生成器中抓一个整数(2), 作为初始化整数for number <= max { // number作为筛子，当筛子超过max的时候结束筛选fmt.Println(number) // 打印素数, 筛子即一个素数nums = filter(nums, number) //筛掉number的倍数number = <- nums  // 更新筛子}
}

func rand01() chan int {ch := make(chan int)go func () {for {select { //select会尝试执行各个case, 如果都可以执行，那么随机选一个执行case ch <- 0:case ch <- 1:}}}()return ch
}func main() {generator := rand01() //初始化一个01随机生成器//测试，打印10个随机01for i := 0; i < 10; i++ {fmt.Println(<-generator)}
}

/*
 * 利用信道做定时器
 */package mainimport ("fmt""time"
)func timer(duration time.Duration) chan bool {ch := make(chan bool)go func() {time.Sleep(duration)ch <- true // 到时间啦！}()return ch
}func main() {timeout := timer(time.Second) // 定时1sfor {select {case <- timeout:fmt.Println("already 1s!") // 到时间return  //结束程序}}
}