并发concurrency

• goroutine只是官方实现的超级“线程池”而已，每个实例4-5kb的栈内存占用和由于实现机制而大幅减少的创建和销毁开销，是制造Go号称的高并发的根本原因。
• 并发不是并行
• 并发主要由切换时间片来实现“同时”运行，在并行则是直接利用多核实现多线程的运行，但Go可以设置使用核数，以发挥多核计算机的能力。
• Goroutine奉行通过通信来共享内存，而不是共享内存来通信

Channel

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

Select

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

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

package main
import (
    "fmt"
)
func main() {
    ch := make(chan bool, 1)//有缓存，异步通道
    go func() {
        fmt.Println("go go go")//结果未输出
        <-ch
    }()
    ch <- true//因为通道里存完就结束了，并不阻塞
}

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 < 10; i++ {
        a += i
    }
    fmt.Println(index, a)
    c <- true
}

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 < 1000; i++ {
        a += i
    }
    fmt.Println(index, a)
    wg.Done()
}

package main
import (
    "fmt"
    "runtime"
)
func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    c1, c2 := make(chan int), make(chan string)
    o := make(chan bool, 2)
    go func() {
        for {
            select {
            case v, ok := <-c1:
                if !ok {
                    fmt.Println("c1")
                    o <- true
                    break
                }
                fmt.Println("c1", v)
            case v, ok := <-c2:
                if !ok {
                    fmt.Println("c2")
                    o <- true
                    break
                }
                fmt.Println("c2", v)
            }
        }
    }()
    c1 <- 1
    c2 <- "hi"
    c1 <- 3
    c2 <- "hello"
    close(c1)
    close(c2)
    for i := 0; i < 2; i++ {
        <-o
    }
}

package main
import (
    "fmt"
    "runtime"
)
func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    c := make(chan int)
    go func() {
        for v := range c {
            fmt.Println(v)
        }
    }()
    for {
        select {
        case c <- 1:
        case c <- 2:
        }
    }
}

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