golang学习笔记之并发优化（一）

golang在并发上面还是很优雅的，有事细节大家可能不太了解。

多处通知

一次当wait阻塞等待done时，如果完成后，所有之前阻塞的wait都将收到通知，这样就可以通知多个协程。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {

    var wg sync.WaitGroup
    wg.Add(1)

    go func() {
        fmt.Println("wait1 enter")
        wg.Wait()
        fmt.Println("wait1 exit")
    }()

    go func() {
        fmt.Println("wait2 enter")
        wg.Wait()
        fmt.Println("wait2 exit")
    }()

    go func() {
        time.Sleep(time.Second)
        fmt.Println("done")
        wg.Done()
    }()

    wg.Wait()
    time.Sleep(time.Second)
    fmt.Println("main exit")
}

结果如下：
wait2 enter
wait1 enter
done
wait1 exit
wait2 exit
main exit
对于管道的close操作也是类似的，所有在此阻塞的管道都将可以继续向下执行，再补充一个例子加深理解

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {

    var wg sync.WaitGroup
    ready := make(chan  int )
    wg.Add(3)
    for i :=0;i<3;i++{
        go func(i int) {
            defer wg.Done()
            fmt.Println("reading",i)
            <-ready
            fmt.Println("go",i)
        }(i)
    }
    time.Sleep(time.Second)
    fmt.Println("ready go")
    close(ready)
    wg.Wait()
}

通过关闭管道或得通知。这样就可以实现组播或者广播

特殊管道

已关闭通道读写

package main

import (
    "fmt"
)

func main() {

    ready := make(chan int,1)
    ready<-2
    close(ready)
    fmt.Println(<-ready)
    fmt.Println(<-ready)

}

像已经关闭的通道写数据或者重复关闭通道都会panic，读是没有问题的，如果有数据会读取到数据，没有的话会读取到零值。
2
0

nil通道读写

针对nil管道，无论是读写都会阻塞

package main

import (
    "fmt"
    "time"
)

func main() {
    var a chan int
    go func() {
        fmt.Println("start")
        //a <-1
        <-a
        fmt.Println("end")
    }()

    fmt.Println(a)
    time.Sleep(time.Second)
    fmt.Println("main exit")
}

结果

start
main exit
这里的end不会输出，应为这里的nil管道会一直阻塞，那么在select里面也是这样，可以通过将通道设置nil从而不被选中

package main

import (
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(3)
    a,b := make(chan int ),make(chan int )

    go func() {
        defer wg.Done()
        for {
        select {
        case x,ok :=<-a:
            if !ok{
               a =nil
                break
            }
            println("a:",x)

        case y,ok :=<-b:
            if !ok{
                b=nil
                break
            }
            println("b:",y)

        }
            if a==nil && b==nil{
                return
            }
        }
    }()
    go func() {
        defer wg.Done()
        defer close(a)
        for i:=0;i<3;i++{
            a<-i
        }
    }()

    go func() {
        defer wg.Done()
        defer close(b)
        for i:=0;i<3;i++{
            b<-i*10
        }
    }()
    wg.Wait()
}

结果为：
b: 0
a: 0
a: 1
b: 10
a: 2
b: 20