原文作者:学生黄哲
来源:简书
•并发(concurrency)是指一次处理大量事情的能力。并发的关键是你有处理多个任务的能力,不一定要同时。
•并行(parallelism)指的是同时处理多个事情。并行的关键是你有同时处理多个任务的能力。
简单的理解一下,并发就是你在跑步的时候鞋带开了,你停下来系鞋带。而并行则是,你一边听歌一边跑步。
并行并不代表比并发快,举一个例子,当文件下载完成时,应该使用弹出窗口来通知用户。而这种通信发生在负责下载的组件和负责渲染用户界面的组件之间。在并发系统中,这种通信的开销很低。而如果这两个组件并行地运行在 CPU 的不同核上,这种通信的开销却很大。因此并行程序并不一定会执行得更快。
Go 原生支持并发。在Go中,使用 Go 协程(Goroutine)和信道(channel)来处理并发。
只需在函数调⽤语句前添加 go 关键字,就可创建并发执⾏单元。开发⼈员⽆需了解任何执⾏细节,调度器会⾃动将其安排到合适的系统线程上执⾏。协程是⼀种⾮常轻量级的实现,可在单个进程⾥执⾏成千上万的并发任务。
•调度器不能保证多个 goroutine 执⾏次序,且进程退出时不会等待它们结束。
•Go 协程之间通过信道(channel)进行通信。
•协程里可以创建协程
1package main
2import (
3 "fmt"
4 "time"
5)
6func hello() {
7 fmt.Println("Hello world goroutine")
8}
9func main() {
10 //开启了一个新的协程。hello() 函数将和 main() 函数一起运行。
11 go hello()
12 time.Sleep(1 * time.Second) //延时结束主程序,不然不能保证主程序会等协程程序
13 fmt.Println("main function")
14}
1package main
2import (
3 "fmt"
4 "time"
5)
6func numbers() {
7 for i := 1; i <= 5; i++ {
8 time.Sleep(250 * time.Millisecond)
9 fmt.Printf("%d ", i)
10 }
11}
12func alphabets() {
13 for i := 'a'; i <= 'e'; i++ {
14 time.Sleep(400 * time.Millisecond)
15 fmt.Printf("%c ", i)
16 }
17}
18func main() {
19 //numbers()和alphabets()并发执行
20 go numbers()
21 go alphabets()
22 time.Sleep(3000 * time.Millisecond)
23 fmt.Println("Main Over")
24}
输出:
1 a 2 3 b 4 c 5 d e Main Over
修改一下上面的代码
1func alphabets() {
2 defer fmt.Println("结束") //defer会被调用
3 for i := 'a'; i <= 'e'; i++ {
4 time.Sleep(400 * time.Millisecond)
5 fmt.Printf("%c ", i)
6 runtime.Goexit() //立即结束该协程
7 }
8}
程序输出则会变为
1 a 结束
2 3 4 5 Main Over
1package main
2import (
3 "fmt"
4 "runtime"
5)
6func main() {
7 go func() { //子协程 //没来的及执行主进程结束
8 for i := 0; i < 5; i++ {
9 fmt.Println(i)
10 }
11 }()
12
13 for i := 0; i < 2; i++ { //默认先执行主进程主进程执行完毕
14 //让出时间片,先让别的协议执行,它执行完,再回来执行此协程
15 runtime.Gosched()
16 fmt.Println("执行")
17 }
18}
信道(Channel)可以被认为是协程之间通信的管道。数据可以从信道的一端发送并在另一端接收。
•默认为同步模式,需要发送和接收配对。否则会被阻塞,直到另⼀⽅准备好后被唤醒。
•信道支持单向信道
信道分为无缓冲信道和有缓冲信道
无缓冲信道:信道是同步的,接收前没有能力保存任何值。这种类型的信道只有发送和接收同时准备好,才能进行下次信道的操作,否则会导致阻塞。
有缓冲信道:信道是异步的,是一种在被创建时就被开辟了能存储一个或者多个值的信道。这种类型并不要求发送与接收同时进行。只要缓冲区有未使用空间用于发送数据,或还包含可以接收的数据,那么其通信就会无阻塞地进行。
信道声明var ch chan T
我们声明了一个T类型的名称叫做ch的信道
信道的 0 值为 nil。我们需要通过内置函数 make 来创建一个信道,就像创建 map 和 slice 一样。
无缓冲信道ch := make(chan T)
有缓冲信道ch := make(chan T,cap)
1//内置类型channel
2 var a chan int
3 if a == nil {
4 a = make(chan int)
5 fmt.Printf("%T\n", a) //chan int
6 }
7 //自定义类型channel
8 var p chan person
9 if p == nil {
10 p = make(chan person) //chan main.person
11 fmt.Printf("%T\n", p)
12 }
1data := <- a // 从信道 a 中读取数据并将读取的值赋值给变量 data 。
2a <- data // 向信道 a 中写入数据。
1package main
2import (
3 "fmt"
4 "time"
5)
6func hello(done chan bool) {
7 fmt.Println("hello go routine is going to sleep")
8 time.Sleep(4 * time.Second)
9 //只有写数据后才能继续执行
10 done <- true
11 fmt.Println("hello go routine awake and going to write to done")
12}
13func main() {
14 done := make(chan bool)
15 go hello(done)
16 <-done
17 fmt.Println("Main received data")
18}
使用信道是要考虑的一个重要因素是死锁(Deadlock)只读未写与只写未读都会触发死锁,并触发 panic 。
channel 上如果发生了流入和流出不配对,就可能会发生死锁。
1package main
2func main() {
3 ch := make(chan int)
4 ch <- 5 //只写未读触发死锁
5}
发送者可以关闭信道以通知接收者将不会再发送数据给信道。v, ok := <- ch
判断信道是否已关闭
1package main
2import (
3 "fmt"
4)
5//只写操作
6func sendData(sendch chan<- int) {
7 sendch <- 10
8
9 //不能读
10 //<-sendch
11
12 close(sendch) //显式关闭信道
13}
14//只读操作
15func readData(sendch <-chan int) {
16 <-sendch
17}
18func main() {
19 sendch := make(chan int)
20 go sendData(sendch)
21 v, ok := <-sendch //ok 返回 true 表示成功的接收到了发送的数据,如果 ok 返回 false 则表示信道已经被关闭。
22 v1, ok1 := <-sendch
23 fmt.Println(v, ok) //10 true
24 fmt.Println(v1, ok1) //0 false
25}
信道支持range for遍历
1package main
2
3import (
4 "fmt"
5 "time"
6)
7
8func producer(chnl chan int) {
9 defer close(chnl) //程序执行结束关闭信道
10 for i := 0; i < 10; i++ {
11 time.Sleep(300 * time.Millisecond) //一秒写一次
12 chnl <- i //写操作
13 }
14}
15func main() {
16 ch := make(chan int)
17 go producer(ch)
18 //接收ch信道中的数据,直到该信道关闭。
19 for v := range ch {
20 fmt.Println(v)
21 }
22}
也可以自定for循环遍历信道
1for {
2 v, ok := <-ch //读操作
3 fmt.Println(v, ok)
4 if ok == false { //当读取不到数据跳出循环
5 break
6 }
7 }
语法结构ch := make(chan type, cap)
cap为容量。
•缓冲信道支持len()和cap()
•只能向缓冲信道发送容量以内的数据
•只能接收缓冲信道长度以内的数据
信道是异步的,是一种在被创建时就被开辟了能存储一个或者多个值的信道。这种类型并不要求发送与接收同时进行。只要缓冲区有未使用空间用于发送数据,或还包含可以接收的数据,那么其通信就会无阻塞地进行。只有在通道中没有要接收的值时,接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时,发送动作才会阻塞。
1func main() {
2 //创建一个容量为3的缓冲信道
3 ch := make(chan string, 3)
4 ch <- "naveen"
5 ch <- "paul"
6 fmt.Println("capacity is", cap(ch)) //capacity is 3
7 fmt.Println("length is", len(ch)) //length is 2
8 fmt.Println("read value", <-ch) //read value naveen
9 fmt.Println("new length is", len(ch)) //new length is 1
10}
假设我们有 3 个并发执行的 Go 协程(由Go 主协程生成)。Go 主协程需要等待这 3 个协程执行结束后,才会终止。这就可以用 WaitGroup 来实现。
1package main
2
3import (
4 "fmt"
5 "sync"
6 "time"
7)
8
9func process(i int, wg *sync.WaitGroup) {
10 fmt.Println("started Goroutine ", i)
11 time.Sleep(2 * time.Second)
12 fmt.Printf("Goroutine %d ended\n", i)
13 //Done方法减少WaitGroup计数器的值,应在线程的最后执行。
14 wg.Done()
15}
16
17/*
18 WaitGroup用于等待一组线程的结束。
19 父线程调用Add方法来设定应等待的线程的数量。
20 每个被等待的线程在结束时应调用Done方法。
21 同时,主线程里可以调用Wait方法阻塞至所有线程结束。
22*/
23func main() {
24 no := 3
25 var wg sync.WaitGroup
26 //并发协程
27 for i := 0; i < no; i++ {
28 /*
29 Add方法向内部计数加上delta,delta可以是负数;
30 如果内部计数器变为0,Wait方法阻塞等待的所有线程都会释放,
31 如果计数器小于0,方法panic。
32 */
33 wg.Add(1)
34 go process(i, &wg)
35 }
36 //Wait方法阻塞直到WaitGroup计数器减为0。
37 wg.Wait()
38 fmt.Println("over")
39}
select 语句用于在多个发送/接收信道操作中进行选择。select 语句会一直阻塞,直到发送/接收操作准备就绪。
•如果有多个信道操作准备完毕,select 会随机地选取其中之一执行。
•空的select会触发死锁因此它会一直阻塞,导致死锁。
1package main
2import (
3 "fmt"
4 "time"
5)
6func server1(ch chan string) {
7 time.Sleep(1 * time.Second)
8 ch <- "from server1"
9}
10func server2(ch chan string) {
11 time.Sleep(1 * time.Second)
12 ch <- "from server2"
13}
14func main() {
15 output1 := make(chan string)
16 output2 := make(chan string)
17 go server1(output1)
18 go server2(output2)
19 //随机选择
20 select {
21 case s1 := <-output1:
22 fmt.Println(s1)
23 case s2 := <-output2:
24 fmt.Println(s2)
25 }
26}
版权申明:内容来源网络,版权归原创者所有。除非无法确认,我们都会标明作者及出处,如有侵权烦请告知,我们会立即删除并表示歉意。谢谢。
Golang语言社区
ID:GolangWeb
www.ByteEdu.Com
游戏服务器架构丨分布式技术丨大数据丨游戏算法学习