GoLang之协程
目前,WebServer几种主流的并发模型:
多线程,每个线程一次处理一个请求,在当前请求处理完成之前不会接收其它请求;但在高并发环境下,多线程的开销比较大;
基于回调的异步IO,如Nginx服务器使用的epoll模型,这种模式通过事件驱动的方式使用异步IO,使服务器持续运转,但人的思维模式是串行的,大量回调函数会把流程分割,对于问题本身的反应不够自然;
协程,不需要抢占式调度,可以有效提高线程的任务并发性,而避免多线程的缺点;但原生支持协程的语言还很少。
协程(coroutine)是Go语言中的轻量级线程实现,由Go运行时(runtime)管理。
在一个函数调用前加上go关键字,这次调用就会在一个新的goroutine中并发执行。当被调用的函数返回时,这个goroutine也自动结束。需要注意的是,如果这个函数有返回值,那么这个返回值会被丢弃。
先看下面的例子:
func Add(x, y int) {
z := x +y
fmt.Println(z)
}
func main() {
for i:=0; i<10; i++{
go Add(i, i)
}
}
执行上面的代码,会发现屏幕什么也没打印出来,程序就退出了。
对于上面的例子,main()函数启动了10个goroutine,然后返回,这时程序就退出了,而被启动的执行Add()的goroutine没来得及执行。我们想要让main()函数等待所有goroutine退出后再返回,但如何知道goroutine都退出了呢?这就引出了多个goroutine之间通信的问题。
在工程上,有两种最常见的并发通信模型:共享内存和消息。
来看下面的例子,10个goroutine共享了变量counter,每个goroutine执行完成后,将counter值加1.因为10个goroutine是并发执行的,所以我们还引入了锁,也就是代码中的lock变量。在main()函数中,使用for循环来不断检查counter值,当其值达到10时,说明所有goroutine都执行完毕了,这时main()返回,程序退出。
package main
import ("fmt"
"sync"
"runtime")
var counterint = 0func Count(lock*sync.Mutex) {
lock.Lock()
counter++fmt.Println("counter =", counter)
lock.Unlock()
}
func main() {
lock := &sync.Mutex{}
for i:=0; i<10; i++{
go Count(lock)
}
for {
lock.Lock()
c :=counter
lock.Unlock()
runtime.Gosched() // 出让时间片if c >= 10{
break
}
}
}
上面的例子,使用了锁变量(属于一种共享内存)来同步协程,事实上Go语言主要使用消息机制(channel)来作为通信模型。
channel
消息机制认为每个并发单元是自包含的、独立的个体,并且都有自己的变量,但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种,那就是消息。
channel是Go语言在语言级别提供的goroutine间的通信方式,我们可以使用channel在多个goroutine之间传递消息。channel是进程内的通信方式,因此通过channel传递对象的过程和调用函数时的参数传递行为比较一致,比如也可以传递指针等。
channel是类型相关的,一个channel只能传递一种类型的值,这个类型需要在声明channel时指定。
channel的声明形式为:
var chanName chan ElementType
举个例子,声明一个传递int类型的channel:
var ch chan int
使用内置函数make()定义一个channel:
ch := make(chan int)
在channel的用法中,最常见的包括写入和读出:
//将一个数据value写入至channel,这会导致阻塞,直到有其他goroutine从这个channel中读取数据
ch
value :=
可以关闭不再使用的channel:
close(ch)
我们还可以创建一个带缓冲的channel:
c := make(chan int, 1024)//从带缓冲的channel中读数据
for i:=range c {
...}
此时,创建一个大小为1024的int类型的channel,即使没有读取方,写入方也可以一直往channel里写入,在缓冲区被填完之前都不会阻塞。
现在利用channel来重写上面的例子:
func Count(ch chan int) {
ch
}
func main() {
chs := make([] chan int, 10)
for i:=0; i<10; i++{
chs[i]= make(chan int)
go Count(chs[i])
}
for _, ch :=range(chs) {
}
}
在这个例子中,定义了一个包含10个channel的数组,并把数组中的每个channel分配给10个不同的goroutine。在每个goroutine完成后,向goroutine写入一个数据,在这个channel被读取前,这个操作是阻塞的。在所有的goroutine启动完成后,依次从10个channel中读取数据,在对应的channel写入数据前,这个操作也是阻塞的。这样,就用channel实现了类似锁的功能,并保证了所有goroutine完成后main()才返回。
另外,我们在将一个channel变量传递到一个函数时,可以通过将其指定为单向channel变量,从而限制该函数中可以对此channel的操作。
单向channel变量的声明:
var ch1 chan int //普通channel
var ch2 chan
var ch3
可以通过类型转换,将一个channel转换为单向的:
ch4 := make(chan int)
ch5 :=
ch6 := chan
单向channel的作用有点类似于c++中的const关键字,用于遵循代码“最小权限原则”。
例如在一个函数中使用单向读channel:
func Parse(ch
for value :=range ch {
fmt.Println("Parsing value", value)
}
}
channel作为一种原生类型,本身也可以通过channel进行传递,例如下面这个流式处理结构:
type PipeData struct {
valueinthandler func(int) intnext chanint}
func handle(queue chan*PipeData) {
for data :=range queue {
data.next
}
}
select
在UNIX中,select()函数用来监控一组描述符,该机制常被用于实现高并发的socket服务器程序。Go语言直接在语言级别支持select关键字,用于处理异步IO问题,大致结构如下:
select {case
default://默认分支
}
Go语言没有对channel提供直接的超时处理机制,但我们可以利用select来间接实现,例如:
timeout := make(chan bool, 1)
go func() {
time.Sleep(1e9)
timeout
switch {case
}
这样使用select就可以避免永久等待的问题,因为程序会在timeout中获取到一个数据后继续执行,而无论对ch的读取是否还处于等待状态。
同步锁
Go语言包中的sync包提供了两种锁类型:sync.Mutex和sync.RWMutex,前者是互斥锁,后者是读写锁。
使用锁的经典模式:
var lck sync.Mutex
func foo() {
lck.Lock()
defer lck.Unlock()//...
}
lck.Lock()会阻塞直到获取锁,然后利用defer语句在函数返回时自动释放锁。
对于从全局角度只需要运行一次的代码,比如全局初始化操作,Go语言提供了一个once类型来保证全局的唯一性操作,如下:
var flag int32
var once sync.Once
func initialize() {
flag= 3fmt.Println(flag)
}
func setup() {
once.Do(initialize)
}
func main() {
setup()
setup()
}
flag只别打印 了一次。
另外,为了更好的地控制并行中的原子操作,sync包还提供了一个atomic子包,支持对于一些基础数据类型的原子操作函数,比如经典的CAS函数:
func CompareAndSwapUnit64(val *uint64, old, new uint64) (swapped bool)
有疑问加站长微信联系(非本文作者)