014.golang 并发concurrency

客官°小女子只卖身不卖艺 2021-10-06 15:08 304阅读 0赞

## 并发concurrency ##

*  很多人都是冲着 Go 大肆宣扬的高并发而忍不住跃跃欲试，但其实从  
    源码的解析来看，goroutine 只是由官方实现的超级“线程池”而已。  
    不过话说回来，每个实例 4-5KB 的栈内存占用和由于实现机制而大幅  
    减少的创建和销毁开销，是制造 Go 号称的高并发的根本原因。另外，  
    goroutine 的简单易用，也在语言层面上给予了开发者巨大的便利。
 *  并发不是并行：Concurrency Is Not Parallelism  
    并发主要由切换时间片来实现“同时”运行，在并行则是直接利用  
    多核实现多线程的运行，但 Go 可以设置使用核数，以发挥多核计算机  
    的能力。
 *  Goroutine 奉行通过通信来共享内存，而不是共享内存来通信。

--------------------

package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        go Go()
        time.Sleep(time.Second)
    }
    
    func Go() {
        fmt.Println("Go GO Go ...")
    }

![这里写图片描述][70]

--------------------

## Channel ##

*  Channel 是 goroutine 沟通的桥梁，大都是阻塞同步的
 *  通过 make 创建，close 关闭
 *  Channel 是引用类型
 *  可以使用 for range 来迭代不断操作 channel
 *  可以设置单向或双向通道
 *  可以设置缓存大小，在未被填满前不会发生阻塞

--------------------

package main
    
    import (
        "fmt"
        "runtime"
    )
    
    func main() {
        runtime.GOMAXPROCS(runtime.NumCPU())
        c := make(chan bool, 10)
        for i := 0; i < 10; i++ {
            go Go(c, i)
        }
        for i := 0; i < 10; i++ {
            <-c
        }
    }
    
    func Go(c chan bool, index int) {
        a := 1
        for i := 0; i < 10000000; i++ {
            a += i
        }
        fmt.Println(index, a)
    
        c <- true
    }

![这里写图片描述][70 1]

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        c := make(chan bool)
        go func() {
            fmt.Println("Go Go Go ...")
            c <- true
        }()
        <-c
    }

![这里写图片描述][70 2]

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        c := make(chan bool)
        go func() {
            fmt.Println("Go Go Go ...")
            c <- true
            close(c)
        }()
    
        for v := range c {
            fmt.Println(v)
        }
    }

![这里写图片描述][70 3]

--------------------

package main
    
    import (
        "fmt"
        "runtime"
        "sync"
    )
    
    func main() {
        runtime.GOMAXPROCS(runtime.NumCPU())
        wg := sync.WaitGroup{}
        wg.Add(10)
        for i := 0; i < 10; i++ { 
            go Go(&wg, i)
        }
        wg.Wait()
    }
    
    func Go(wg *sync.WaitGroup, index int) {
        a := 1
        for i := 0; i < 10000000; i++ { 
            a += i
        }
        fmt.Println(index, a)
    
        wg.Done()
    }

![这里写图片描述][70 4]

--------------------

## Select ##

*  可处理一个或多个 channel 的发送与接收
 *  同时有多个可用的 channel时按随机顺序处理
 *  可用空的 select 来阻塞 main 函数
 *  可设置超时

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        c1, c2 := make(chan int), make(chan string)
        o := make(chan bool)
        go func() {
            for {
                select {
                case v, ok := <-c1:
                    if !ok {
                        o <- true
                        break
                    }
                    fmt.Println("c1", v)
                case v, ok := <-c2:
                    if !ok {
                        o <- true
                        break
                    }
                    fmt.Println("c2", v)
                }
            }
        }()
    
        c1 <- 1
        c2 <- "hello"
        c1 <- 2
        c2 <- "world"
        close(c1)
        close(c2)
        <-o
    
    }

![这里写图片描述][70 5]

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        //随机输出 0 或 1
        c := make(chan int)
    
        go func() {
            for v := range c {
                fmt.Println(v)
            }
        }()
    
        for {
            select {
            case c <- 0:
            case c <- 1:
            }
        }
    
    }

![这里写图片描述][70 6]

--------------------

package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        c := make(chan bool)
        select {
        case v := <-c:
            fmt.Println(v)
        case <-time.After(3 * time.Second):
            fmt.Println("Timeout")
        }
    }

![这里写图片描述][70 7]

[70]: /images/20211006/c1ae27178e714aa892e6338ca391c761.png
[70 1]: /images/20211006/fb699b5a1f994c8ca016a62dc688d682.png
[70 2]: /images/20211006/f2f83cb389a44cac9acacf13b70c64af.png
[70 3]: /images/20211006/de0550c219fc46e39d27a6c1df4ba595.png
[70 4]: /images/20211006/2f299cffad56458eac0c74eede326e74.png
[70 5]: /images/20211006/b03e1191e82f48909cf5bc28b103d862.png
[70 6]: /images/20211006/00608cc794ac4dafb3cb6265b8a1016b.png
[70 7]: /images/20211006/65d4e0f43151496598220ac6610f6800.png