Go的Goroutine的使用

并发 concurrency

• Goroutine 通过通信来共享内存,而不是通过共享内存来通信

1. Channel是Goroutine的沟通桥梁,引用类型,大都是阻塞同步的
2. make创建,close关闭
3. for range迭代操作channel,可以设置单向或者双向管道,缓存大小,为填满之前不会堵塞

• Select

1. 可以处理一个或者多个channel的发送和接收
2. 同时有多个可以用的chnnel随机顺序处理
3. 可设置空的select阻塞main函数,可设置超时

• 单向管道 chan<-int只发送同道,<-chan int，只接受通道

func initV(out chan<- int) {
    for i := 0; i < 1000; i++ {
        out <- i
    }
    close(out)
}

func squar(in <-chan int, out chan<- int) {
    for i := range in {
        out <- i * i;
    }
    close(out)
}

func print(in <-chan int) {
    for i := range in {
        fmt.Println("value is:", i)
    }
}

    x:=make(chan int)
    y:=make(chan int)
    go initV(x)
    go squar(x,y)
     print(y)

chan异步处理循环打印

func ChanRange(index int,c chan bool) {
    a := 0
    for i := 0; i < 100000000; i++ {
        a += i
    }
    fm.Println("a value is:",index, a)
    c<-true//设置chan值
}

func goChan() {//达到异步执行
    runtime.GOMAXPROCS(1)/设置cpu最大可用核数
    c := make(chan bool,10)//设置缓存大小,有缓存的时候是异步的,无缓存是同步堵塞
    for i := 0; i < 10; i++ {
        go my.ChanRange(i,c)//开启一个新的goroutine执行
    }
    for i:=0;i<10;i++{
        <-c//取出chan值
    }

}

sync异步循环打印

func SyncRange(index int,wg *sync.WaitGroup) {
    a := 0
    for i := 0; i < 100000000; i++ {
        a += i
    }
    fm.Println("a value is:",index, a)
    wg.Done()//执行完毕一个,线程池就会减少一个线程
}

func goSync() {//达到异步执行
    //runtime.GOMAXPROCS(runtime.NumCPU())/设置cpu最大可用核数
    wg:=sync.WaitGroup{}
    wg.Add(10)
    for i := 0; i < 10; i++ {
        go my.SyncRange(i,&wg)
    }
    wg.Wait()

}

并发不是并行,==老的版本默认==,Go所有的goroutines只能在一个线程里跑,也就是说,设置核数为1地，goChan方法不是并行的，是并发的，==新版本默认==把runtime.GOMAXPROCS(runtime.NumCPU())设置最大的,那么他就是并行的

• 两个队列，一个Coffee机器，那是并发
• 两个队列，两个Coffee机器，那是并行

package main

import (
    "fmt"
)

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

func main() {
    go say("world") //开一个新的Goroutines执行
    for {
    }
}

这里Go仍然在使用单核，for死循环占据了单核CPU所有的资源，而main线和say两个goroutine都在一个线程里面，所以say没有机会执行

• 允许Go使用多核(runtime.GOMAXPROCS)

• 手动显式调动runtime包(runtime包是goroutine的调度器),

1. • Gosched 让出cpu
2. • NumCPU 返回当前系统的CPU核数量
3. • GOMAXPROCS 设置最大的可同时使用的CPU核数
4. • Goexit 退出当前goroutine(但是defer语句会照常执行)

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
    }
}

- 上面代码这种主动让出CPU时间的方式仍然是在单核里跑。但手工地切换goroutine导致了看上去的“并行”，stackoverflow的 解释:https://stackoverflow.com/questions/13107958/what-exactly-does-runtime-gosched-do

当一个goroutine发生阻塞，Go会自动地把与该goroutine处于同一系统线程的其他goroutines转移到另一个系统线程上去，以使这些goroutines不阻塞,也就是说,goroutine不阻塞不放开CPU

package main

import (
    "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++ { //开三个goroutine
        go loop(i)
    }

    for i := 0; i < 3; i++ {
        <- quit
    }
}

select的使用

• 多chan 处理

func TwoMoreChan() {
    c1, c2 := make(chan bool), make(chan int)
    o := make(chan bool)

    go func() {
        for {
            select {
            case v, ok := <-c1:
                if !ok {
                    o <- true
                    break
                }
                fm.Println("c1 value is:", v)
            case v, ok := <-c2:
                if !ok {
                    o <- true
                    break
                }
                fm.Println("c2 value is:", v)
            }
        }
    }()

    c1 <- false
    c2 <- 0
    c1 <- true
    c2 <- 2

    close(c1) 
}

• 设置超时处理

func SelectTime() {
    c := make(chan bool)
    select {
    case v := <-c:
        fm.Println("c value is:", v)
    case <-time.After(3 * time.Second):
        fm.Println("time out")
    }
}