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