Go 并发的一些总结
GO并发
goroutine
goroutine是Go并行设计的核心。goroutine说到底其实就是协程，可是它比线程更小，十几个goroutine可能体如今底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB)，固然会根据相应的数据伸缩。也正由于如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。程序员
Go routine并不会运行得比线程更快更快，它只是增长了更多的并发性。当一个goroutine被阻塞（好比等待IO），golang的scheduler会调度其它能够执行的goroutine运行。与线程相比，它有如下几个优势：golang
-
内存消耗更少：shell
- Goroutine所须要的内存一般只有2kb，而线程则须要1Mb（500倍）。
-
建立与销毁的开销更小编程
- 因为线程建立时须要向操做系统申请资源，而且在销毁时将资源归还，所以它的建立和销毁的开销比较大。相比之下，goroutine的建立和销毁是由go语言在运行时本身管理的，所以开销更低。
-
切换开销更小缓存
- 这是goroutine于线程的主要区别，也是golang可以实现高并发的主要缘由。线程的调度方式是抢占式的，若是一个线程的执行时间超过了分配给它的时间片，就会被其它可执行的线程抢占。在线程切换的过程当中须要保存/恢复全部的寄存器信息，好比16个通用寄存器，PC（Program Counter），SP（Stack Pointer），段寄存器等等。
goroutine是经过Go的runtime管理的一个线程管理器。goroutine经过go关键字实现了，就是一个普通的函数。安全
go hello(a, b, c)
经过关键字go启动goroutine。网络
package main
import (
"fmt"
"runtime"
)
func say(s string) {
for i := 0; i < 5; i++ {
runtime.Gosched()
fmt.Println(s)
}
}
func main() {
go say("world") //开一个新的Goroutines执行
say("hello") //当前Goroutines执行
}
// 以上程序执行后将输出：
// hello
// world
// hello
// world
// hello
// world
// hello
// world
// hello
能够看到go关键字很方便的就实现了并发编程。
上面的多个goroutine运行在同一个进程里面，共享内存数据，不过设计上咱们要遵循：不要经过共享来通讯，而要经过通讯来共享。数据结构
runtime.Gosched()表示让CPU把时间片让给别人,下次某个时候继续恢复执行该goroutine。默认状况下，在Go 1.5将标识并发系统线程个数的runtime.GOMAXPROCS的初始值由1改成了运行环境的CPU核数。并发
但在Go 1.5之前调度器仅使用单线程，也就是说只实现了并发。想要发挥多核处理器的并行，须要在咱们的程序中显式调用 runtime.GOMAXPROCS(n) 告诉调度器同时使用多个线程。GOMAXPROCS 设置了同时运行逻辑代码的系统线程的最大数量，并返回以前的设置。若是n < 1，不会改变当前设置。异步
正如前面提到的，goroutine的调度方式是协同式的。在协同式调度中，没有时间片的概念。为了并行执行goroutine，调度器会在如下几个时间点对其进行切换：
- Channel接受或者发送会形成阻塞的消息
- 当一个新的goroutine被建立时
- 能够形成阻塞的系统调用，如文件和网络操做
channels
不一样goroutine之间通信
- 全局变量的互斥锁
- 使用管道channel来解决
channle本质就是一个数据结构-队列
数据是先进先出【FIFO : first in first out】
线程安全，多goroutine访问时，不须要加锁，就是说channel自己就是线程安全的
channel有类型的，一个string的channel只能存放string类型数据。
Go 语言中使用了CSP模型来进行线程通讯，准确说，是轻量级线程goroutine之间的通讯。CSP模型和Actor模型相似，也是由独立的，并发执行的实体所构成，实体之间也是经过发送消息进行通讯的。Actor模型和CSP模型区别Actor之间直接通信，而CSP是经过Channel通信，在耦合度上二者是有区别的，后者更加松耦合。主要的区别在于：CSP模型中消息的发送者和接收者之间经过Channel松耦合，发送者不知道本身消息被哪一个接收者消费了，接收者也不知道是哪一个发送者发送的消息。在Actor模型中，因为Actor能够根据本身的状态选择处理哪一个传入消息，自主性可控性更好些。在Go语言中为了避免堵塞进程，程序员必须检查不一样的传入消息，以便预见确保正确的顺序。CSP好处是Channel不须要缓冲消息，而Actor理论上须要一个无限大小的邮箱做为消息缓冲。CSP模型的消息发送方只能在接收方准备好接收消息时才能发送消息。相反，Actor模型中的消息传递是异步的，即消息的发送和接收无需在同一时间进行，发送方能够在接收方准备好接收消息前将消息发送出去。
goroutine运行在相同的地址空间，所以访问共享内存必须作好同步。Go提供了一个很好的goroutine之间进行数据的通讯的机制channel。channel能够与Unix shell 中的双向管道作类比：能够经过它发送或者接收值。这些值只能是特定的类型：channel类型。定义一个channel时，也须要定义发送到channel的值的类型。注意，必须使用make 建立channel：
ci := make(chan int)
cs := make(chan string)
cf := make(chan interface{})
channel经过操做符<-来接收和发送数据
ch <- v // 发送v到channel ch. v := <-ch // 从ch中接收数据，并赋值给v
把这些应用到咱们的例子中来：
package main
import "fmt"
func sum(a []int, c chan int) {
total := 0
for _, v := range a {
total += v
}
c <- total // send total to c
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(a[:len(a)/2], c)
go sum(a[len(a)/2:], c)
x, y := <-c, <-c // receive from c
fmt.Println(x, y, x + y)
}
默认状况下，channel接收和发送数据都是阻塞的，除非另外一端已经准备好，这样就使得Goroutines同步变的更加的简单，而不须要显式的lock。所谓阻塞，也就是若是读取（value := <-ch）它将会被阻塞，直到有数据接收。其次，任何发送（ch<-5）将会被阻塞，直到数据被读出。无缓冲channel是在多个goroutine之间同步很棒的工具。
Buffered Channels
上面咱们介绍了默认的非缓存类型的channel，不过Go也容许指定channel的缓冲大小，很简单，就是channel能够存储多少元素。ch:= make(chan bool, 4)，建立了能够存储4个元素的bool 型channel。在这个channel 中，前4个元素能够无阻塞的写入。当写入第5个元素时，代码将会阻塞，直到其余goroutine从channel 中读取一些元素，腾出空间。
ch := make(chan type, value)
当 value = 0 时，channel 是无缓冲阻塞读写的，当value > 0 时，channel 有缓冲、是非阻塞的，直到写满 value 个元素才阻塞写入。
看一下下面这个例子
package main
import "fmt"
func main() {
c := make(chan int, 2)//修改2为1就报错，修改2为3能够正常运行
c <- 1
c <- 2
fmt.Println(<-c)
fmt.Println(<-c)
}
//修改成1报以下的错误:
//fatal error: all goroutines are asleep - deadlock!
总结：channel使用的注意事项
- channel中只能存放指定的数据类型
- channle的数据放满后，就不能再放入了
- 若是从channel取出数据后，能够继续放入
- 在没有使用协程的状况下，若是channel数据取完了，再取，就会报dead lock
Range和Close
上面这个例子中，咱们须要读取两次c，这样不是很方便，Go考虑到了这一点，因此也能够经过range，像操做slice或者map同样操做缓存类型的channel，请看下面的例子
package main
import (
"fmt"
)
func fibonacci(n int, c chan int) {
x, y := 1, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x + y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
for i := range c可以不断的读取channel里面的数据，直到该channel被显式的关闭。上面代码咱们看到能够显式的关闭channel，生产者经过内置函数close关闭channel。关闭channel以后就没法再发送任何数据了，在消费方能够经过语法v, ok := <-ch测试channel是否被关闭。若是ok返回false，那么说明channel已经没有任何数据而且已经被关闭。
记住应该在生产者的地方关闭channel，而不是消费的地方去关闭它，这样容易引发panic另外记住一点的就是channel不像文件之类的，不须要常常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的
Select
上面介绍的都是只有一个channel的状况，那么若是存在多个channel的时候，该如何操做呢，Go里面提供了一个关键字select，经过select能够监听channel上的数据流动。
select默认是阻塞的，只有当监听的channel中有发送或接收能够进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 1, 1
for {
select {
case c <- x:
x, y = y, x + y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
在select里面还有default语法，select其实就是相似switch的功能，default就是当监听的channel都没有准备好的时候，默认执行的（select再也不阻塞等待channel）。
select {
case i := <-c:
// use i
default:
// 当c阻塞的时候执行这里
}
超时
有时候会出现goroutine阻塞的状况，那么如何避免整个程序进入阻塞的状况呢？咱们能够利用select来设置超时，经过以下的方式实现：
func main() {
c := make(chan int)
o := make(chan bool)
go func() {
for {
select {
case v := <- c:
println(v)
case <- time.After(5 * time.Second):
println("timeout")
o <- true
break
}
}
}()
<- o
}
runtime goroutine
runtime包中有几个处理goroutine的函数：
- Goexit
退出当前执行的goroutine，可是defer函数还会继续调用
- Gosched
让出当前goroutine的执行权限，调度器安排其余等待的任务运行，并在下次某个时候从该位置恢复执行。
- NumCPU
返回 CPU 核数量
- NumGoroutine
返回正在执行和排队的任务总数
- GOMAXPROCS
用来设置能够并行计算的CPU核数的最大值，并返回以前的值。
- 1. 关于go并发编程的总结
- 2. go语言的一些基础总结
- 3. golang总结-并发
- 4. App开发一些总结
- 5. h5开发的一些我的总结
- 6. Deadlock的一些总结
- 7. 索引的一些总结
- 8. 关于Android开发的一些总结
- 9. 驱动开发的一些总结
- 10. 微信开发的一些总结
- 更多相关文章...
- • Rust 并发编程 - RUST 教程
- • XML 总结 下一步学习什么呢？ - XML 教程
- • 算法总结-归并排序
- • 算法总结-双指针
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 关于go并发编程的总结
- 2. go语言的一些基础总结
- 3. golang总结-并发
- 4. App开发一些总结
- 5. h5开发的一些我的总结
- 6. Deadlock的一些总结
- 7. 索引的一些总结
- 8. 关于Android开发的一些总结
- 9. 驱动开发的一些总结
- 10. 微信开发的一些总结