关于golang:Goroutine

Goroutine 的概念相似于线程，但 goroutine 是由 Go 的运行时（runtime）调度和治理的。Go 程序会智能地将 goroutine 中的工作正当地调配给每个 CPU。Go 语言之所以被称为现代化的编程语言，就是因为它在语言层面曾经内置了调度和上下文切换的机制。

在 Go 语言编程中你不须要去本人写过程、线程、协程，你的技能包里只有一个技能–goroutine，当你须要让某个工作并发执行的时候，你只须要把这个工作包装成一个函数，开启一个 goroutine 去执行这个函数就能够了，就是这么简略粗犷。

Go 语言中应用 goroutine 非常简单，只须要在调用函数的时候在后面加上 go 关键字，就能够为一个函数创立一个 goroutine。

一个 goroutine 必然对应一个函数，能够创立多个 goroutine 去执行雷同的函数。

func main() {go hello() // 启动另外一个 goroutine 去执行 hello 函数
    fmt.Println("main goroutine done!")
    time.Sleep(time.Second)
}

启动多个 Goroutine

var wg sync.WaitGroup

func hello(i int) {defer wg.Done() // goroutine 完结就注销 -1
    fmt.Println("Hello Goroutine!", i)
}
func main() {

    for i := 0; i < 10; i++ {wg.Add(1) // 启动一个 goroutine 就注销 +1
        go hello(i)
    }
    wg.Wait() // 期待所有注销的 goroutine 都完结}

这里应用了 sync.WaitGroup 代替下面的 sleep 来实现 goroutine 的同步；这 10 个 goroutine 是并发执行的，而 goroutine 的调度是随机的。

让出 CPU 工夫片，该语句前面的工作期待重新安排

package main

import (
    "fmt"
    "runtime"
)

func main() {go func(s string) {
        for i := 0; i < 20; i++ {fmt.Println(s)
        }
    }("优先执行")
    // 主协程
    for i := 0; i < 20; i++ {
        // 让出 CPU 工夫片，从新期待安顿工作
        runtime.Gosched()
        fmt.Println("失常执行")
    }
}

退出以后协程

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {go func() {defer fmt.Println("外层退出")
        func() {defer fmt.Println("内层退出")
            // 完结协程
            runtime.Goexit()}()}()
    time.Sleep(time.Second *1)
}

Go 运行时的调度器应用 GOMAXPROCS 参数来确定须要应用多少个 OS 线程来同时执行 Go 代码。默认值是机器上的 CPU 外围数。例如在一个 8 外围的机器上，调度器会把 Go 代码同时调度到 8 个 OS 线程上，Go 语言中能够通过 runtime.GOMAXPROCS() 函数设置以后程序并发时占用的 CPU 逻辑外围数。咱们能够通过将任务分配到不同的 CPU 逻辑外围上实现并行的成果。

package main

import (
    "fmt"
    "runtime"
    "time"
)

func a() {
    for i := 1; i < 100; i++ {fmt.Println("A:", i)
    }
}

func b() {
    for i := 1; i < 100; i++ {fmt.Println("B:", i)
    }
}

func main() {runtime.GOMAXPROCS(2)
    go a()
    go b()
    time.Sleep(time.Second)
}

当 runtime.GOMAXPROCS(1) 时，两个工作只有一个逻辑外围，此时是做完一个工作再做另一个工作，当 runtime.GOMAXPROCS(2) 时，此时两个工作并行执行。

OS 线程（操作系统线程）个别都有固定的栈内存（通常为 2MB）, 一个 goroutine 的栈在其生命周期开始时只有很小的栈（典型状况下 2KB），goroutine 的栈不是固定的，他能够按需增大和放大，goroutine 的栈大小限度能够达到 1GB，尽管极少会用到这个大。所以在 Go 语言中一次创立十万左右的 goroutine 也是能够的。

GPM 是 Go 语言运行时（runtime）层面的实现，是 go 语言本人实现的一套调度零碎。区别于操作系统调度 OS 线程。

1.G：很好了解，就是个 goroutine，外面除了寄存本 goroutine 信息外还有与所在 P 的绑定等信息。
2.P：processor 处理器，治理着一组 goroutine 队列，P 外面会存储以后 goroutine 运行的上下文环境（函数指针，堆栈地址及地址边界），P 会对本人治理的 goroutine 队列做一些调度（比方把占用 CPU 工夫较长的 goroutine 暂停、运行后续的 goroutine 等等）当本人的队列生产完了就去全局队列里取，如果全局队列里也生产完了会去其余 P 的队列里抢工作。
3.M（machine）是 Go 运行时（runtime）对操作系统内核线程的虚构，相当于 thread 线程，M 与内核线程个别是一一映射的关系，一个 groutine 最终是要放到 M 上执行的；

P 与 M 个别也是一一对应的。他们关系是：P 治理着一组 G 挂载在 M 上运行。当一个 G 短暂阻塞在一个 M 上时，runtime 会新建一个 M，阻塞 G 所在的 P 会把其余的 G 挂载在新建的 M 上。当旧的 G 阻塞实现或者认为其曾经死掉时回收旧的 M。

P 的个数是通过 runtime.GOMAXPROCS 设定（最大 256），Go1.5 版本之后默认为物理线程数。在并发量大的时候会减少一些 P 和 M，但不会太多，切换太频繁的话得失相当。

单从线程调度讲，Go 语言相比起其余语言的劣势在于 OS 线程是由 OS 内核来调度的，goroutine 则是由 Go 运行时（runtime）本人的调度器调度的，这个调度器应用一个称为 m:n 调度的技术（复用 / 调度 m 个 goroutine 到 n 个 OS 线程）。其一大特点是 goroutine 的调度是在用户态下实现的，不波及内核态与用户态之间的频繁切换，包含内存的调配与开释，都是在用户态保护着一块大的内存池，不间接调用零碎的 malloc 函数（除非内存池须要扭转），老本比调度 OS 线程低很多。另一方面充分利用了多核的硬件资源，近似的把若干 goroutine 均分在物理线程上，再加上自身 goroutine 的超轻量，以上种种保障了 go 调度方面的性能。

关于golang:Goroutine

什么是 Goroutine

应用 Goroutine

启动单个 Goroutine

runtime 包

runtime.Gosched()

runtime.Goexit()

runtime.GOMAXPROCS

Goroutine 与线程

可增长的栈

Goroutine 的调度