golang学习笔记 ---并发

预备知识
1.1 进程、线程、协程

进程（Process）：在内存中的程序。有自己独立的独占的虚拟 CPU 、虚拟的 Memory、虚拟的 IO devices。　　

OS 直接支持并调度。进程之间只能通过系统提供的 IO 机制通讯。共享内存（变量）是不可能的！

(1) 每一进程占用独立的地址空间。

此处的地址空间包括代码、数据及其他资源。
(2) 进程间的通信开销较大且受到许多限制。

对象（或函数）接口、通信协议、…
(3) 进程间的切换开销也较大。

又称Context Switch。
上下文包括代码、数据、堆栈、处理器状态、资源、…

线程（Thread）：轻量级进程。在现代操作系统中，是进程中程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。

一个进程由若干线程组成，它们共享进程的计算、存储、IO资源。因此，程序员必须使用系统提供的同步、消息机制，处理资源的竞争和消息的通讯。

　　

(1) 多个线程共享进程的地址空间（代码、数据、其他资源等）。

线程也需要自己的资源，如程序计数器、寄存器组、调用栈等。
(2) 线程间的通信开销较少且比较简单。

因为共享而减少了需要通信的内容。
但也因为充分共享而无法对共享资源进行保护。
(3) 线程间的切换开销也较小。

只需保存每一线程的程序计数器、寄存器组、堆栈等空间。
不必切换或复制整个地址空间，从而成本大为降低（约1/10）
线程有分为两大类：

操作系统管理的线程（Core Thread），通常根据 CPU 资源决定线程的数量，一般为 CPU 数量的两倍。
语言提供的线程库管理的线程（User Thread），它执行时映射到系统线程，按任务类型（计算密集型，IO密集型）决定线程池的管理方式与数量。

协程（coroutine/fiber）：轻量级线程。 是可以并发执行的函数，由编译或用户指定位置将控制权交给协程调度程序执行的方式。它是非抢占式的，可以避免反复系统调用，还有进程切换造成的开销，给你上几千个逻辑流，也称用户级别线程。

　

并行和并发

并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。

并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

并行是两个队列同时使用两台咖啡机，并发是两个队列交替使用一台咖啡机

Go语言并发优势

有人把Go比作21世纪的C语言，第一是因为Go语言设计简单，第二，21世纪最重要的就是并行程序设计，而Go从语言层面就支持了并行。同时，并发程序的内存管理有时候是非常复杂的，而Go语言提供了自动垃圾回收机制。Go语言中有个概念叫做goroutine, 这类似我们熟知的线程，但是更轻。一般情况下，一个普通的桌面计算机跑十几二十个线程就有点负载过大了，但是同样这台机器却可以轻松地让成百上千甚至过万个goroutine进行资源竞争。

goroutine是什么

goroutine是Go并行设计的核心。goroutine说到底其实就是协程，但是它比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。　

创建goroutine
只需在函数调⽤语句前添加 go 关键字，就可创建并发执⾏单元。开发⼈员无需了解任何执⾏细节，调度器会自动将其安排到合适的系统线程上执行。在并发编程里，我们通常想讲一个过程切分成几块，然后让每个goroutine各自负责一块工作。当一个程序启动时，其主函数即在一个单独的goroutine中运行，我们叫它main goroutine。新的goroutine会用go语句来创建。

package main
 
import (
    "fmt"
    "time"
)
 
func newTask() {
    i := 0
    for {
        i++
        fmt.Printf("new goroutine: i = %d\n", i)
        time.Sleep(1 * time.Second) //延时1s
    }
}
 
func main() { 
    go newTask()   //创建一个 goroutine，启动另外一个任务
    i := 0
    for {          //main goroutine 循环打印
        i++
        fmt.Printf("main goroutine: i = %d\n", i)
        time.Sleep(1 * time.Second) //延时1s
    }
}

程序运行结果：

main goroutine: i = 15

new goroutine: i = 15

new goroutine: i = 16

main goroutine: i = 16

new goroutine: i = 17

main goroutine: i = 17

new goroutine: i = 18

main goroutine: i = 18

main goroutine: i = 19

new goroutine: i = 19

new goroutine: i = 20

main goroutine: i = 20

main goroutine: i = 21

new goroutine: i = 21

new goroutine: i = 22

main goroutine: i = 22

。。。

　　

串行地去执行两次loop函数:

package main

import (
	"fmt"
)

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
}

func main() {
	loop()
	loop()
}

　　

输出会是这样的:

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

　

把一个loop放在一个goroutine里跑，我们可以使用关键字go来定义并启动一个goroutine:

package main

import (
	"fmt"
	"time"
)

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
}

func main() {
	go loop()
	loop()
	time.Sleep(time.Second)
}

注意，如果不用　time.Sleep(time.Second), 则可能在goroutine还没来得及跑loop的时候，主函数已经退出了

main函数退出地太快了，我们要想办法阻止它过早地退出，一个办法是让main等待一下:，目的达到了。可是采用等待的办法并不好，如果goroutine在结束的时候，告诉下主线说“Hey, 我要跑完了！”就好了，这就是接下来要讲到的信道。

 

信道

信道是什么？简单说，是goroutine之间互相通讯的东西。类似我们Unix上的管道（可以在进程间传递消息）， 用来goroutine之间发消息和接收消息。其实，就是在做goroutine之间的内存共享。

　　示例：

package main

import (
	"fmt"
)

func main() {
	var messages chan string = make(chan string)
	go func(message string) {
		messages <- message // 存消息
	}("Ping!")
	fmt.Println(<-messages) // 取消息
}

　　

默认的，信道的存消息和取消息都是阻塞的 (叫做无缓冲的信道，不过缓冲这个概念稍后了解，先说阻塞的问题)。

也就是说, 无缓冲的信道在取消息和存消息的时候都会挂起当前的goroutine，除非另一端已经准备好。

package main

import (
	"fmt"
)

var ch chan int = make(chan int)

func foo() {
	ch <- 0 // 向ch中加数据，如果没有其他goroutine来取走这个数据，那么挂起foo, 直到main函数把0这个数据拿走
}

func main() {
	go foo()
	data := <-ch // 从ch取数据，如果ch中还没放数据，那就挂起main线，直到foo函数中放数据为止
	fmt.Println(data)

}

　　

那既然信道可以阻塞当前的goroutine, 那么回到上一部分「goroutine」所遇到的问题「如何让goroutine告诉主线我执行完毕了」 的问题来, 使用一个信道来告诉主线即可:

package main

import (
	"fmt"
)

var complete chan int = make(chan int)

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
	complete <- 0 // 执行完毕了，发个消息
}

func main() {
	go loop()
	<-complete // 直到线程跑完, 取到消息. main在此阻塞住

}

　　

如果不用信道来阻塞主线的话，主线就会过早跑完，loop线都没有机会执行、、、

其实，无缓冲的信道永远不会存储数据，只负责数据的流通，为什么这么讲呢？

从无缓冲信道取数据，必须要有数据流进来才可以，否则当前线阻塞

数据流入无缓冲信道, 如果没有其他goroutine来拿走这个数据，那么当前线阻塞
无缓冲信道的大小都是0 (len(channel))

 

如果信道正有数据在流动，我们还要加入数据，或者信道干涩，我们一直向无数据流入的空信道取数据呢？ 就会引起死锁

死锁

一个死锁的例子:

package main

func main() {
	ch := make(chan int)
	<-ch // 阻塞main goroutine, 信道c被锁
}

　　执行结果：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
	D:/GOWORK/src/jsonstudy/main.go:5 +0x2c

　　

何谓死锁? 操作系统有讲过的，所有的线程或进程都在等待资源的释放。如上的程序中, 只有一个goroutine, 所以当你向里面加数据或者存数据的话，都会锁死信道， 并且阻塞当前 goroutine, 也就是所有的goroutine(其实就main线一个)都在等待信道的开放(没人拿走数据信道是不会开放的)，也就是死锁咯。

package main

import (
	"fmt"
)

func f(ch chan int) {
	ch <- 10 // 将一个数据value写入至channel，这会导致阻塞，直到有其他goroutine从这个channel中读取数据
}

func main() {
	var ch chan int     // 声明一个传递int类型的channel
	ch = make(chan int) // 使用内置函数make()定义一个channel
	go f(ch)
	//=========

	value := <-ch // 从channel中读取数据，如果channel之前没有写入数据，也会导致阻塞，直到channel中被写入数据为止
	fmt.Println(value)

	//=========
	close(ch)

}

　　总结来看，为什么会死锁？非缓冲信道上如果发生了流入无流出，或者流出无流入，也就导致了死锁。或者这样理解 Go启动的所有goroutine里的非缓冲信道一定要一个线里存数据，一个线里取数据，要成对才行 。所以下面的示例一定死锁:

package main

func main() {
	c, quit := make(chan int), make(chan int)

	go func() {
		c <- 1    // c通道的数据没有被其他goroutine读取走，堵塞当前goroutine
		quit <- 0 // quit始终没有办法写入数据
	}()

	<-quit // quit 等待数据的写

}

　　

仔细分析的话，是由于：主线等待quit信道的数据流出，quit等待数据写入，而func被c通道堵塞，所有goroutine都在等，所以死锁。

简单来看的话，一共两个线，func线中流入c通道的数据并没有在main线中流出，肯定死锁。

package main

func main() {
	
    c := make(chan int)
 
    go func() {
       c <- 1
    }()


}

　　

程序正常退出了，很简单，并不是我们那个总结不起作用了，还是因为一个让人很囧的原因，main又没等待其它goroutine，自己先跑完了， 所以没有数据流入c信道，一共执行了一个goroutine, 并且没有发生阻塞，所以没有死锁错误

那么死锁的解决办法呢？

最简单的，把没取走的数据取走，没放入的数据放入， 因为无缓冲信道不能承载数据，那么就赶紧拿走！

 

package main

func main() {

	c, quit := make(chan int), make(chan int)

	go func() {
		c <- 1
		quit <- 0
	}()

	<-c // 取走c的数据！
	<-quit

}

一个解决办法是缓冲信道, 即设置c有一个数据的缓冲大小:

c := make(chan int, 1)

　　

这样的话，c可以缓存一个数据。也就是说，放入一个数据，c并不会挂起当前线, 再放一个才会挂起当前线直到第一个数据被其他goroutine取走, 也就是只阻塞在容量一定的时候，不达容量不阻塞。

无缓冲信道的数据进出顺序
我们已经知道，无缓冲信道从不存储数据，流入的数据必须要流出才可以。

package main

import (
	"fmt"
)

var ch chan int = make(chan int)

func foo(id int) { //id: 这个routine的标号
	ch <- id
}

func main() {
	for i := 0; i < 5; i++ { // 开启5个routine
		go foo(i)
	}
	for i := 0; i < 5; i++ { // 取出信道中的数据
		fmt.Print(<-ch)
	}
}

　　

输出：01234

我们开了5个goroutine，然后又依次取数据。其实整个的执行过程细分的话，5个线的数据 依次流过信道ch, main打印之, 而宏观上我们看到的即 无缓冲信道的数据是先到先出，但是 无缓冲信道并不存储数据，只负责数据的流通

缓冲信道
终于到了这个话题了, 其实缓存信道用英文来讲更为达意: buffered channel.

缓冲这个词意思是，缓冲信道不仅可以流通数据，还可以缓存数据。它是有容量的，存入一个数据的话 , 可以先放在信道里，不必阻塞当前线而等待该数据取走。

当缓冲信道达到满的状态的时候，就会表现出阻塞了，因为这时再也不能承载更多的数据了，「你们必须把 数据拿走，才可以流入数据」。

在声明一个信道的时候，我们给make以第二个参数来指明它的容量(默认为0，即无缓冲):

var ch chan int = make(chan int, 2) // 写入2个元素都不会阻塞当前goroutine, 存储个数达到2的时候会阻塞

　　如下的例子，缓冲信道ch可以无缓冲的流入3个元素:

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
}

　　

如果你再试图流入一个数据的话，信道ch会阻塞main线, 报死锁。

也就是说，缓冲信道会在满容量的时候加锁。

其实，缓冲信道是先进先出的，我们可以把缓冲信道看作为一个线程安全的队列：

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
 
    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
    fmt.Println(<-ch) // 3
}

　　

信道数据读取和信道关闭

你也许发现，上面的代码一个一个地去读取信道简直太费事了，Go语言允许我们使用range来读取信道

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
 
    for v := range ch {
        fmt.Println(v)
    }
}

　

如果你执行了上面的代码，会报死锁错误的，原因是range不等到信道关闭是不会结束读取的。也就是如果 缓冲信道干涸了，那么range就会阻塞当前goroutine, 所以死锁咯。

那么，我们试着避免这种情况，比较容易想到的是读到信道为空的时候就结束读取:

ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
for v := range ch {
    fmt.Println(v)
    if len(ch) <= 0 { // 如果现有数据量为0，跳出循环
        break
    }
}

以上的方法是可以正常输出的，但是注意检查信道大小的方法不能在信道存取都在发生的时候，用于取出所有数据，这个例子 是因为我们只在ch中存了数据，现在一个一个往外取，信道大小是递减的。　

或者显式地关闭信道:

func main() {
	ch := make(chan int, 3)
	ch <- 1
	ch <- 2
	ch <- 3

	for v := range ch {
		fmt.Println(v)
		if len(ch) <= 0 {
			close((ch))
		}
	}
}

　　

被关闭的信道会禁止数据流入, 是只读的。我们仍然可以从关闭的信道中取出数据，但是不能再写入数据了。

package main

import (
	"fmt"
	"time"
)

func produce(p chan<- int) {
	for i := 0; i < 10; i++ {
		p <- i
		fmt.Println("send:", i)
	}
}
func consumer(c <-chan int) {
	for i := 0; i < 10; i++ {
		v := <-c
		fmt.Println("receive:", v)
	}
}
func main() {
	ch := make(chan int)
	go produce(ch)
	go consumer(ch)
	time.Sleep(1 * time.Second)
}

　输出：

receive: 0

send: 0

send: 1

receive: 1

receive: 2

send: 2

send: 3

receive: 3

receive: 4

send: 4

send: 5

receive: 5

receive: 6

send: 6

send: 7

receive: 7

receive: 8

send: 8

send: 9

receive: 9

　

在这段代码中，因为channel是没有缓冲的，所以当生产者给channel赋值后，生产者这个线程会阻塞，直到消费者线程将channel中的数据取出。消费者第一次将数据取出后，进行下一次循环时，消费者的线程也会阻塞，因为生产者还没有将数据存入，这时程序会去执行生产者的线程。程序就这样在消费者和生产者两个线程间不断切换，直到循环结束。

下面我们再看一个带缓冲的例子：

package main

import (
	"fmt"
	"time"
)

func produce(p chan<- int) {
	for i := 0; i < 10; i++ {
		p <- i
		fmt.Println("send:", i)
	}
}
func consumer(c <-chan int) {
	for i := 0; i < 10; i++ {
		v := <-c
		fmt.Println("receive:", v)
	}
}
func main() {
	ch := make(chan int, 10)
	go produce(ch)
	go consumer(ch)
	time.Sleep(1 * time.Second)
}

　　输出：

send: 0

send: 1

send: 2

send: 3

send: 4

send: 5

send: 6

send: 7

send: 8

send: 9

receive: 0

receive: 1

receive: 2

receive: 3

receive: 4

receive: 5

receive: 6

receive: 7

receive: 8

receive: 9

 

在这个程序中，缓冲区可以存储10个int类型的整数，在执行生产者线程的时候，线程就不会阻塞，一次性将10个整数存入channel，在读取的时候，也是一次性读取。

等待多gorountine的方案
那好，我们回到最初的一个问题，使用信道堵塞主线，等待开出去的所有goroutine跑完。

这是一个模型，开出很多小goroutine, 它们各自跑各自的，最后跑完了向主线报告。

我们讨论如下2个版本的方案:

只使用单个无缓冲信道阻塞主线

使用容量为goroutines数量的缓冲信道

对于方案1, 示例的代码大概会是这个样子:

package main

import (
	"fmt"
)

var quit chan int // 只开一个信道

func foo(id int) {
	fmt.Println(id)
	quit <- 0 // ok, finished
}

func main() {
	count := 1000
	quit = make(chan int) // 无缓冲

	for i := 0; i < count; i++ {
		go foo(i)
	}

	for i := 0; i < count; i++ {
		<-quit
	}
}

　　

对于方案2, 把信道换成缓冲1000的:

package main

import (
	"fmt"
)

var count = 1000

func foo(id int, quit chan int) {
	fmt.Println(id)
	quit <- 0 // ok, finished
}

func main() {

	quit := make(chan int, count) // 容量1000
	for i := 0; i < count; i++ {
		go foo(i, quit)
	}

	for i := 0; i < count; i++ {
		<-quit
	}
}

　　或者

package main

import (
	"fmt"
)

var count = 1000
var quit = make(chan int, count) // 容量1000

func foo(id int) {

	fmt.Println(id)
	quit <- 0 // ok, finished
}

func main() {

	for i := 0; i < count; i++ {
		go foo(i)
	}

	for i := 0; i < count; i++ {
		<-quit
	}
}

　　

其实区别仅仅在于一个是缓冲的，一个是非缓冲的。

对于这个场景而言，两者都能完成任务, 都是可以的。

• 无缓冲的信道是一批数据一个一个的「流进流出」

• 缓冲信道则是一个一个存储，然后一起流出去

Go语言的并发和并行

package main

import (
	"fmt"
)

var quit chan int = make(chan int)

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
	quit <- 0
}

func main() { // 开两个goroutine跑函数loop, loop函数负责打印10个数
	go loop()
	go loop()
	for i := 0; i < 2; i++ {
		<-quit
	}

}

　　

　输出：

 

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

 

 

并行和并发

从概念上讲，并发和并行是不同的

• 两个队列，一个Coffee机器，那是并发
• 两个队列，两个Coffee机器，那是并行

从上面的两个例子执行后的表现来看，多个goroutine跑loop函数会挨个goroutine去进行，而sleep则是一起执行的。这是为什么？

默认地， Go所有的goroutines只能在一个线程里跑 。也就是说， 以上两个代码都不是并行的，但是都是是并发的。

　

如果当前goroutine不发生阻塞，它是不会让出CPU给其他goroutine的, 所以例子一中的输出会是一个一个goroutine进行的，而sleep函数则阻塞掉了 当前goroutine, 当前goroutine主动让其他goroutine执行, 所以形成了逻辑上的并行, 也就是并发

真正的并行

为了达到真正的并行，我们需要告诉Go我们允许同时最多使用多个核。

回到起初的例子，我们设置最大开2个原生线程, 我们需要用到runtime包(runtime包是goroutine的调度器):

package main

import (
	"fmt"
	"runtime"
)

var quit chan int = make(chan int)

func loop() {
	for i := 0; i < 100; i++ { //为了观察，跑多些
		fmt.Printf("%d ", i)
	}
	quit <- 0
}

func main() {
	runtime.GOMAXPROCS(2) // 最多使用2个核
	go loop()
	go loop()
	for i := 0; i < 2; i++ {
		<-quit
	}
}

　　这下会看到两个goroutine会抢占式地输出数据了。

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 0 1 2 3 4 5 6 7 8 9 10 11 12 26 27 28 29 30 31 32 33 34 35 36 37 38 39 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 37 38 39 40 41 42 43 44 45 88 89 90 91 92 93 94 95 96 97 98 99 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 

 

我们还可以这样显式地让出CPU时间：

package main

import (
	"fmt"
	"runtime"
)

var quit chan int = make(chan int)

func loop() {
	for i := 0; i < 10; i++ {
		runtime.Gosched() // 显式地让出CPU时间给其他goroutine
		fmt.Printf("%d ", i)
	}
	quit <- 0
}

func main() {
	go loop()
	go loop()
	for i := 0; i < 2; i++ {
		<-quit
	}
}

　　

观察下结果会看到这样有规律的输出:

0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

其实，这种主动让出CPU时间的方式仍然是在单核里跑。但手工地切换goroutine导致了看上去的“并行”。

 

 

如下的程序，按照理解应该打印下5次 "world"呀，可是为什么什么也没有打印

package main

import "fmt"

func say(s string) {
	for i := 0; i < 5; i++ {
		fmt.Println(s)
	}
}

func main() {
	go say("world") //开一个新的Goroutines执行
	for {
	}
}

　　

楼下的答案已经很棒了，这里Go仍然在使用单核，for死循环占据了单核CPU所有的资源，而main线和say两个goroutine都在一个线程里面， 所以say没有机会执行。解决方案还是两个：

允许Go使用多核(runtime.GOMAXPROCS)

手动显式调动(runtime.Gosched)

关于runtime包几个函数:

• Gosched 让出cpu
• NumCPU 返回当前系统的CPU核数量
• GOMAXPROCS 设置最大的可同时使用的CPU核数
• Goexit 退出当前goroutine(但是defer语句会照常执行)

总结
我们从例子中可以看到，默认的, 所有goroutine会在一个原生线程里跑，也就是只使用了一个CPU核。

在同一个原生线程里，如果当前goroutine不发生阻塞，它是不会让出CPU时间给其他同线程的goroutines的，这是Go运行时对goroutine的调度，我们也可以使用runtime包来手工调度。

我们可以在Golang官方网站的这里 找到一句话:

When a coroutine blocks, such as by calling a blocking system call, the run-time automatically moves other coroutines on the same operating system thread to a different, runnable thread so they won't be blocked.

也就是说:

当一个goroutine发生阻塞，Go会自动地把与该goroutine处于同一系统线程的其他goroutines转移到另一个系统线程上去，以使这些goroutines不阻塞

package main

import (
	"fmt"
	"runtime"
)

var quit chan int = make(chan int)

func loop(id int) { // id: 该goroutine的标号
	for i := 0; i < 10; i++ { //打印10次该goroutine的标号
		fmt.Printf("%d ", id)
	}
	quit <- 0
}

func main() {
	runtime.GOMAXPROCS(2) // 最多同时使用2个核

	for i := 0; i < 3; i++ { //开三个goroutine
		go loop(i)
	}

	for i := 0; i < 3; i++ {
		<-quit
	}
}

跑几次会看到类似这些输出(不同机器环境不一样):

0 0 0 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 2 2 2 2 0 0 0 0 0 0

2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 1 2 2 2 1 1 1 1 1 1 1 1 1 

2 2 2 2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1

 

goroutine不阻塞不放开CPU

执行它我们会发现以下现象:

• 有时会发生抢占式输出(说明Go开了不止一个原生线程，达到了真正的并行)
• 有时会顺序输出, 打印完0再打印1, 再打印2(说明Go开一个原生线程，单线程上的goroutine不阻塞不松开CPU)

那么，我们还会观察到一个现象，无论是抢占地输出还是顺序的输出，都会有那么两个数字表现出这样的现象:

• 一个数字的所有输出都会在另一个数字的所有输出之前

原因是， 3个goroutine分配到至多2个线程上，就会至少两个goroutine分配到同一个线程里，单线程里的goroutine 不阻塞不放开CPU, 也就发生了顺序输出。

4 runtime包
4.1 Gosched
runtime.Gosched() 用于让出CPU时间片，让出当前goroutine的执行权限，调度器安排其他等待的任务运行，并在下次某个时候从该位置恢复执行。

这就像跑接力赛，A跑了一会碰到代码runtime.Gosched() 就把接力棒交给B了，A歇着了，B继续跑。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	//创建一个goroutine
	go func(s string) {
		for i := 0; i < 2; i++ {
			fmt.Println(s)
		}
	}("world")

	for i := 0; i < 2; i++ {
		runtime.Gosched() //import "runtime"
		/*
		   屏蔽runtime.Gosched()运行结果如下：
		       hello
		       hello
		   没有runtime.Gosched()运行结果如下：
		       world
		       world
		       hello
		       hello
		*/
		fmt.Println("hello")
	}
}

　　

4.2 Goexit
调用 runtime.Goexit() 将立即终止当前 goroutine 执⾏，调度器确保所有已注册 defer 延迟调用被执行。

示例代码：

package main

import (
	"fmt"
	"runtime"
)

func main() {
	go func() {
		defer fmt.Println("A.defer")

		func() {
			defer fmt.Println("B.defer")
			runtime.Goexit() // 终止当前 goroutine, import "runtime"
			fmt.Println("B") // 不会执行
		}()

		fmt.Println("A") // 不会执行
	}() //别忘了()

	//死循环，目的不让主goroutine结束
	for {
	}
}

　　

程序运行结果： 

1.  B.defer
2.  A.defer

4.3 GOMAXPROCS

调用 runtime.GOMAXPROCS() 用来设置可以并行计算的CPU核数的最大值，并返回之前的值。

示例代码：

func main() {
    //n := runtime.GOMAXPROCS(1) //打印结果：111111111111111111110000000000000000000011111...
    n := runtime.GOMAXPROCS(2)     //打印结果：010101010101010101011001100101011010010100110...
    fmt.Printf("n = %d\n", n)
 
    for {
        go fmt.Print(0)
        fmt.Print(1)
    }
}

　　

在第一次执行(runtime.GOMAXPROCS(1))时，最多同时只能有一个goroutine被执行。所以
会打印很多1。过了一段时间后，GO调度器会将其置为休眠，并唤醒另一个goroutine，这时候就开始打印很多0了，在打印的时候，goroutine是被调度到操作系统线程上的。

在第二次执行(runtime.GOMAXPROCS(2))时，我们使用了两个CPU，所以两个goroutine可以一起被执行，以同样的频率交替打印0和1。

1 select作用

Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。

 

select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。

 

与switch语句可以选择任何可使用相等比较的条件相比， select有比较多的限制，其中最大的一条限制就是每个case语句里必须是一个IO操作，大致的结构如下：

    select {
    case <-chan1:
        // 如果chan1成功读到数据，则进行该case处理语句
    case chan2 <- 1:
        // 如果成功向chan2写入数据，则进行该case处理语句
    default:
        // 如果上面都没有成功，则进入default处理流程
    }

　　

在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句。

 

如果其中的任意一语句可以继续执行(即没有被阻塞)，那么就从那些可以执行的语句中任意选择一条来使用。

 

如果没有任意一条语句可以执行(即所有的通道都被阻塞)，那么有两种可能的情况：

 

• 如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。
• 如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。

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 < 6; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
 
    fibonacci(c, quit)
}

　程序运行结果： 

1
2
3
4
5
6
7
8
quit

　　超时

有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：

func main() {
    c := make(chan int)
    o := make(chan bool)
    go func() {
        for {
            select {
            case v := <-c:
                fmt.Println(v)
            case <-time.After(5 * time.Second):
                fmt.Println("timeout")
                o <- true
                break
            }
        }
    }()
    //c <- 666 // 注释掉，引发 timeout
    <-o
}

　　select有几个重要的点要强调：

1.如果有多个case都可以运行，select会随机公平地选出一个执行，其他不会执行 

select有几个重要的点要强调：

1.如果有多个case都可以运行，select会随机公平地选出一个执行，其他不会执行 

　　

输出：

（随机）二者其一

2.case后面必须是channel操作，否则报错。

 

　

 

　

1 select作用Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。
select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。
与switch语句可以选择任何可使用相等比较的条件相比， select有比较多的限制，其中最大的一条限制就是每个case语句里必须是一个IO操作，大致的结构如下：
    select {    case <-chan1:        // 如果chan1成功读到数据，则进行该case处理语句    case chan2 <- 1:        // 如果成功向chan2写入数据，则进行该case处理语句    default:        // 如果上面都没有成功，则进入default处理流程    }在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句。
如果其中的任意一语句可以继续执行(即没有被阻塞)，那么就从那些可以执行的语句中任意选择一条来使用。
如果没有任意一条语句可以执行(即所有的通道都被阻塞)，那么有两种可能的情况：
如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。示例代码：
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 < 6; i++ {            fmt.Println(<-c)        }        quit <- 0    }()     fibonacci(c, quit)}程序运行结果： 
12345678quit2 超时
有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：
func main() {    c := make(chan int)    o := make(chan bool)    go func() {        for {            select {            case v := <-c:                fmt.Println(v)            case <-time.After(5 * time.Second):                fmt.Println("timeout")                o <- true                break            }        }    }()    //c <- 666 // 注释掉，引发 timeout    <-o}select有几个重要的点要强调：
1.如果有多个case都可以运行，select会随机公平地选出一个执行，其他不会执行 
func main() {    ch := make (chan int, 1)     ch<-1    select {    case <-ch:        fmt.Println("Good luck!")    case <-ch:        fmt.Println("Good day!")    }}输出：
（随机）二者其一
2.case后面必须是channel操作，否则报错。
func main() {    ch := make (chan int, 1)    ch<-1    select {    case <-ch:        fmt.Println("Good luck!")    case 2:        fmt.Println("Good day!")    }}输出报错：
2 evaluated but not usedselect case must be receive, send or assign recv
3.select中的default子句总是可运行的。所以没有default的select才会阻塞等待事件 上代码：
func main() {    ch := make (chan int, 1)    // ch<-1   <= 注意这里备注了。    select {    case <-ch:        fmt.Println("Good luck!")    default:        fmt.Println("Good day!")    }}输出：
Good day!
4.没有运行的case，那么江湖阻塞事件发生报错(死锁)
func main() {    ch := make (chan int, 1)    // ch<-1   <= 注意这里备注了。    select {    case <-ch:        fmt.Println("Good luck!")    }}输出报错：
fatal error: all goroutines are asleep - deadlock!
select的应用场景
1.timeout 机制(超时判断)
func main() {    timeout := make (chan bool, 1)    go func() {        time.Sleep(1*time.Second) // 休眠1s，如果超过1s还没I操作则认为超时，通知select已经超时啦～        timeout <- true    }()    ch := make (chan int)    select {    case <- ch:    case <- timeout:        fmt.Println("超时啦!")    }}以上是入门版，通常代码中是这么写的：
func main() {    ch := make (chan int)    select {    case <-ch:    case <-time.After(time.Second * 1): // 利用time来实现，After代表多少时间后执行输出东西        fmt.Println("超时啦!")    }}2.判断channel是否阻塞(或者说channel是否已经满了)
func main() {    ch := make (chan int, 1)  // 注意这里给的容量是1    ch <- 1    select {    case ch <- 2:    default:        fmt.Println("通道channel已经满啦，塞不下东西了!")    }}3.退出机制
func main() {    i := 0    ch := make(chan string, 0)    defer func() {        close(ch)    }()     go func() {        DONE:         for {            time.Sleep(1*time.Second)            fmt.Println(time.Now().Unix())            i++             select {            case m := <-ch:                println(m)                break DONE // 跳出 select 和 for 循环            default:            }        }    }()     time.Sleep(time.Second * 4)    ch<-"stop"}输出：
153239047115323904721532390473stop1532390474
这边要强调一点：退出循环一定要用break + 具体的标记，或者goto也可以。否则其实不是真的退出。
func main() {    i := 0    ch := make(chan string, 0)    defer func() {        close(ch)    }()     go func() {         for {            time.Sleep(1*time.Second)            fmt.Println(time.Now().Unix())            i++             select {            case m := <-ch:                println(m)                goto DONE // 跳出 select 和 for 循环            default:            }        }        DONE:    }()     time.Sleep(time.Second * 4)    ch<-"stop"}输出:
1532390525153239052615323905271532390528stop
9.select死锁select不注意也会发生死锁，前文有提到一个，这里分几种情况，重点再次强调：
1.如果没有数据需要发送，select中又存在接收通道数据的语句，那么将发送死锁
func main() {      ch := make(chan string)    select {    case <-ch:    }}预防的话加default。
空select，也会引起死锁
package main func main() {      select {}} 
goroutine 编程相关的库
1 尽可能避免使用 runtime 库的函数和方法
尽管你可以使用以下函数，但不建议你使用。
GOMAXPROCS 设置 M 数量，除非你打算写 coroutineGoexit 退出当前 goroutine, 用 close(c) 或 select 通知 goroutine 退出GoroutineProfile 除非 debugGosched 放弃 yield 当前的 M ， 用 time.sleep(1) 更稳健NumGoroutine 当前 goroutine 数量LockOSThread/UnLockOSThread 强制 goroutine 独占 M 直到 Unlock， 除非你打算做客户化函数的调度2 最常用的类型与库
channel 类型与通讯：
读、写 channel，阻塞 goroutineselect case，或 select case default 读多个 channel 阻塞 goroutine （见 gotour concurrency）close channel消息（数据）驱动编程！time 库
sleep() : Sleep pauses the current goroutine。这是最重要的语句，要及时让 runtime 调度 goroutineTick(d Duration): 定周期产生时间消息After(d Duration)： 定时产生消息Timer： 类型
func main() {    tick := time.Tick(100 * time.Millisecond)    boom := time.After(500 * time.Millisecond)    for {        select {        case t := <-tick:            fmt.Println("tick.", t)        case t := <-boom:            fmt.Println("BOOM!")            return//      default://          fmt.Println("    .")//          time.Sleep(50 * time.Millisecond)        }    }}加 default 和 不加 default 的区别？…
时间事件是 goroutine 的最重要事件源之一！
sync 库 Mutex ：互斥量。WaitGroup：信号量Cond：带锁的通知量Once 确保函数线程安全地仅只执行一次。（做单实例的神器）3 集合类型都不是线程安全的
slicemap
利用sync.WaitGroup实现协程同步      使用sync.WaitGroup。WaitGroup顾名思义，就是用来等待一组操作完成的。WaitGroup内部实现了一个计数器，用来记录未完成的操作个数，它提供了三个方法，Add()用来添加计数。Done()用来在操作结束时调用，使计数减一。Wait()用来等待所有的操作结束，即计数变为0，该函数会在计数不为0时等待，在计数为0时立即返回。 
package main import (    "fmt"    "sync") func main() {     var wg sync.WaitGroup     wg.Add(2) // 因为有两个动作，所以增加2个计数    go func() {        fmt.Println("Goroutine 1")        wg.Done() // 操作完成，减少一个计数    }()     go func() {        fmt.Println("Goroutine 2")        wg.Done() // 操作完成，减少一个计数    }()     wg.Wait() // 等待，直到计数为0}GMP调度（）
操作系统中的程序可以往下分解为进程、线程和协程。Go中，协程被称为goroutine，被runtime进行调度。GMP调度中，G代表goroutine，M代表线程，P是Processor，它包含了运行goroutine的资源，只有当 M 关联一个 P 后才能执行 G 。
调度器的两大思想：
复用线程：2个体现：1.work stealing，当本线程无可运行的G时，尝试从其它县城绑定的P偷取G，而不是销毁线程；2.hand off，当本线程因为G进行系统调用阻塞是，线程释放绑定的P，把P转移给其它空闲的线程执行；利用并行：GOMAXPROCS设置P的数量，当GOMAXPROCS大于1时，就最多有GOMAXPROCS个线程处于运行状态，这些线程可能分布在多个CPU核上同时运行，使得并发利用并行。
在Go中，线程是运行goroutine的实体，调度器的功能就是把可运行的goroutine分配到工作线程上。
 
前天去面试，被问到golang是如何实现高并发的，之前在 GO并发编程实战 这本书看到过介绍，但是没有引起重视。传统的并发形式：多线程共享内存，这也是Java、C#或者C++等语言中的多线程开发的常规方法，其实golang语言也支持这种传统模式，另外一种是Go语言特有的，也是Go语言推荐的：CSP（communicating sequential processes）并发模型。不同于传统的多线程通过共享内存来通信，CSP讲究的是“以通信的方式来共享内存”。“不要以共享内存的方式来通信，相反，要通过通信来共享内存。”
go语言使用MPG模式来实现CSP在传统的并发中起很多线程只会加大CPU和内存的开销，太多的线程会大量的消耗计算机硬件资源，造成并发量的瓶颈。
M指的是Machine，一个M直接关联了一个内核线程。P指的是”processor”，代表了M所需的上下文环境，也是处理用户级代码逻辑的处理器。G指的是Goroutine，其实本质上也是一种轻量级的线程。


我个人的理解：M关联了一个内核线程，通过调度器P（上下文）的调度，可以连接1个或者多个G,相当于把一个内核线程切分成了了N个用户线程，M和P是一对一关系（但是实际调度中关系多变），通过P调度N个G（P和G是一对多关系），实现内核线程和G的多对多关系（M:N），通过这个方式，一个内核线程就可以起N个Goroutine，同样硬件配置的机器可用的用户线程就成几何级增长，并发性大幅提高。 ————————————————版权声明：本文为CSDN博主「wade3015」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/wade3015/article/details/88133145