go语言并发goroutine(七)

1.goroutine基础

goroutine 是go语言实现的核心，实质就是线程，
goroutine 是通过go语言runtime管理的一个线程
管理器，goroutine通过go关键字来实现，其实就
是一个普通的函数

import (
    "fmt"
    "runtime"
)

func say(s string) {
    for i:= 0; i < 5; i++ {
        runtime.Gosched()  //把时间片让给别人
        fmt.Println(s)
    }
}

func main() {
    //runtime.GOMAXPROCS(2) //告诉调度器使用几个线程  
    go say("world")  //开一个新的Goroutines执行
    say("hello")     //当前Gorutines执行
    say("tod")  
}

2.goroutine channels

goroutine运行在相同的地址空间，因此访问共享内存必须做好同步
go语言提供了一个很好的通信机制channel，channel可以与Unix
shell 中的双向管道做类比，通过它发送或者接收值，这些值只能是
特定的类型：channel类型，定义一个channel时，也需要定义发送到
channel值得类型，注意：必须使用make创建channel
channel通过操作符 "<-" 来接收和发送数据

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，
这样就使得Goroutinus同步变得简单，而不需要显示的lock，所谓阻塞，
就是如果读取(value := <- ch), 它将会阻塞，直到有数据接收，另外，
任何发送(ch <- value)将会被阻塞，直到数据被读出，无缓冲channel
是在多个goroutine之间同步很好的工具

import "fmt"

func sum(a []int, c chan int) {
    sum := 0
    for _, v := range a {
        sum += v
    }
     
    c <- sum //发送sum值到chann c中
 }

 func main() {
    a := []int{1, 2, 3, 4, 5, 6}
    c := make(chan int)
    go sum(a[:len(a)/2], c)
    go sum(a[len(a)/2:], c)

    x, y := <-c, <-c  //接收chann c的值
    fmt.Println(x, y, x + y)
    fmt.Println("exit")
 }

3.Buffered Channels

channel也可以指定缓冲区的大小
ch := make(chan bool, 4),创建了可以存储4个元素
的bool型channel，在这个channel中，前4个元素可以
无阻塞的写入，当写入第5个元素时，代码将会阻塞，
直到其他goroutine从channel中读取一些元素，腾出空间

import "fmt"

//使用range读取chann buff中的值
func fibonacci(n int, c chan int) {
    x := 0
    for i := 0; i < n; i++ {
        x += 1
        c <- x
    }
    close(c) //关闭chann
}

func main() {
    c := make(chan int, 2)
    c <- 1
    c <- 2
    fmt.Println(<- c)
    fmt.Println(<- c)

    c1 := make(chan int, 10)
    go fibonacci(cap(c1), c1)

    //用range的方式读取chann buff中的值
    for i:= range c1 {
        fmt.Println(i)
    }
}

4.select

当我们使用多个chann的时候可以用select来做监听

import "fmt"

func fibo(c, quit chan int) {
    x, y := 1, 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
    }()
    fibo(c, quit)
}

5.timeout

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int)
    o := make(chan bool)

    go func() {
        for {
            select {
            case v := <- c:
                fmt.Println(v)
            case <- time.After(5 * time.Second):
                fmt.Println("timeout")
                o <- true
                break
            }
        }
    }()
}