本文的主要内容是:

  • 了解goroutine,使用它来运行程序
  • 了解Go是如何检测并修正竞争状态的(解决资源互斥访问的方式)
  • 了解并使用通道chan来同步goroutine

一、使用goroutine来运行程序

1.Go的并发与并行

Go的并发能力,是指让某个函数独立于其他函数运行的能力。当为一个函数创建goroutine时,该函数将作为一个独立的工作单元,被 调度器 调度到可用的逻辑处理器上执行。Go的运行时调度器是个复杂的软件,它做的工作大致是:

  • 管理被创建的所有goroutine,为其分配执行时间
  • 将操作系统线程与语言运行时的逻辑处理器绑定

参考The Go scheduler ,这里较浅显地说一下Go的运行时调度器。操作系统会在物理处理器上调度操作系统线程来运行,而Go语言的运行时会在逻辑处理器上调度goroutine来运行,每个逻辑处理器都分别绑定到单个操作系统线程上。这里涉及到三个角色:

  • M:操作系统线程,这是真正的内核OS线程
  • P:逻辑处理器,代表着调度的上下文,它使goroutine在一个M上跑
  • G:goroutine,拥有自己的栈,指令指针等信息,被P调度

每个P会维护一个全局运行队列(称为runqueue),处于ready就绪状态的goroutine(灰色G)被放在这个队列中等待被调度。在编写程序时,每当go func启动一个goroutine时,runqueue便在尾部加入一个goroutine。在下一个调度点上,P就从runqueue中取出一个goroutine出来执行(蓝色G)。

当某个操作系统线程M阻塞的时候(比如goroutine执行了阻塞的系统调用),P可以绑定到另外一个操作系统线程M上,让运行队列中的其他goroutine继续执行:

上图中G0执行了阻塞操作,M0被阻塞,P将在新的系统线程M1上继续调度G执行。M1有可能是被新创建的,或者是从线程缓存中取出。Go调度器保证有足够的线程来运行所有的P,语言运行时默认限制每个程序最多创建10000个线程,这个现在可以通过调用runtime/debug包的SetMaxThreads方法来更改。

Go可以在在一个逻辑处理器P上实现并发,如果需要并行,必须使用多于1个的逻辑处理器。Go调度器会把goroutine平等分配到每个逻辑处理器上,此时goroutine将在不同的线程上运行,不过前提是要求机器拥有多个物理处理器。

2.创建goroutine

使用关键字go来创建一个goroutine,并让所有的goroutine都得到执行:

//example1.go
package main import (
"runtime"
"sync"
"fmt"
) var (
wg sync.WaitGroup
) func main() {
//分配一个逻辑处理器P给调度器使用
runtime.GOMAXPROCS(1)
//在这里,wg用于等待程序完成,计数器加2,表示要等待两个goroutine
wg.Add(2)
//声明1个匿名函数,并创建一个goroutine
fmt.Printf("Begin Coroutines\n")
go func() {
//在函数退出时,wg计数器减1
defer wg.Done()
//打印3次小写字母表
for count := 0; count < 3; count++ {
for char := 'a'; char < 'a'+26; char++ {
fmt.Printf("%c ", char)
}
}
}()
//声明1个匿名函数,并创建一个goroutine
go func() {
defer wg.Done()
//打印大写字母表3次
for count := 0; count < 3; count++ {
for char := 'A'; char < 'A'+26; char++ {
fmt.Printf("%c ", char)
}
}
}() fmt.Printf("Waiting To Finish\n")
//等待2个goroutine执行完毕
wg.Wait() }

这个程序使用 runtime.GOMAXPROCS(1)来分配一个逻辑处理器给调度器使用,两个goroutine将被该逻辑处理器调度并发执行。程序输出:

Begin Coroutines
Waiting To Finish
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z

从输出来看,是先执行完一个goroutine,再接着执行第二个goroutine的,大写字母全部打印完后,再打印全部的小写字母。那么,有没有办法让两个goroutine并行执行呢?为程序指定两个逻辑处理器即可:

//修改为2个逻辑处理器
runtime.GOMAXPROCS(2)

此时执行程序,输出为:

Begin Coroutines
Waiting To Finish
A B C D E a b c d e f g h i j k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z a b c F G H I J K L M N O P Q R S T U V W X d e f g h i j k l m n o p q r s Y Z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

那如果只有1个逻辑处理器,如何让两个goroutine交替被调度?实际上,如果goroutine需要很长的时间才能运行完,调度器的内部算法会将当前运行的goroutine让出,防止某个goroutine长时间占用逻辑处理器。由于示例程序中两个goroutine的执行时间都很短,在为引起调度器调度之前已经执行完。不过,程序也可以使用runtime.Gosched()来将当前在逻辑处理器上运行的goruntine让出,让另一个goruntine得到执行:

//example2.go
package main import (
"runtime"
"sync"
"fmt"
) var (
wg sync.WaitGroup
) func main() {
//分配一个逻辑处理器P给调度器使用
runtime.GOMAXPROCS(1)
//在这里,wg用于等待程序完成,计数器加2,表示要等待两个goroutine
wg.Add(2)
//声明1个匿名函数,并创建一个goroutine
fmt.Printf("Begin Coroutines\n")
go func() {
//在函数退出时,wg计数器减1
defer wg.Done()
//打印3次小写字母表
for count := 0; count < 3; count++ {
for char := 'a'; char < 'a'+26; char++ {
if char=='k'{
runtime.Gosched()
}
fmt.Printf("%c ", char)
}
}
}()
//声明1个匿名函数,并创建一个goroutine
go func() {
defer wg.Done()
//打印大写字母表3次
for count := 0; count < 3; count++ {
for char := 'A'; char < 'A'+26; char++ {
if char == 'K'{
runtime.Gosched()
}
fmt.Printf("%c ", char)
}
}
}() fmt.Printf("Waiting To Finish\n")
//等待2个goroutine执行完毕
wg.Wait() }

两个goroutine在循环的字符为k/K的时候会让出逻辑处理器,程序的输出结果为:

Begin Coroutines
Waiting To Finish
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J a b c d e f g h i j K L M N O P Q R S T U V W X Y Z A B C D E F G H I J k l m n o p q r s t u v w x y z a b c d e f g h i j K L M N O P Q R S T U V W X Y Z k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z

这里大小写字母果然是交替着输出了。不过从输出可以看到,第一次输出大写字母时遇到K没有让出逻辑处理器,这是什么原因还不是很清楚,调度器的调度机制?

二、处理竞争状态

并发程序避免不了的一个问题是对资源的同步访问。如果多个goroutine在没有互相同步的情况下去访问同一个资源,并进行读写操作,这时goroutine就处于竞争状态下:

//example3.go
package main import (
"sync"
"runtime"
"fmt"
) var (
//counter为访问的资源
counter int64
wg sync.WaitGroup
) func addCount() {
defer wg.Done()
for count := 0; count < 2; count++ {
value := counter
//当前goroutine从线程退出
runtime.Gosched()
value++
counter=value
}
} func main() {
wg.Add(2)
go addCount()
go addCount()
wg.Wait()
fmt.Printf("counter: %d\n",counter)
}
//output:
counter: 4 或者counter: 2

这段程序中,goroutinecounter的读写操作没有进行同步,goroutine 1对counter的写结果可能被goroutine 2所覆盖。Go可通过如下方式来解决这个问题:

  • 使用原子函数操作
  • 使用互斥锁锁住临界区
  • 使用通道chan

1. 检测竞争状态

有时候竞争状态并不能一眼就看出来。Go 提供了一个非常有用的工具,用于检测竞争状态。使用方式是:

go build -race example4.go//用竞争检测器标志来编译程序

./example4 //运行程序

工具检测出了程序存在一处竞争状态,并指出发生竞争状态的几行代码是:

22        counter=value
18 value := counter
28 go addCount()
29 go addCount()

2. 使用原子函数

对整形变量或指针的同步访问,可以使用原子函数来进行。这里使用原子函数来修复example4.go中的竞争状态问题:

//example5.go
package main import (
"sync"
"runtime"
"fmt"
"sync/atomic"
) var (
//counter为访问的资源
counter int64
wg sync.WaitGroup
) func addCount() {
defer wg.Done()
for count := 0; count < 2; count++ {
//使用原子操作来进行
atomic.AddInt64(&counter,1)
//当前goroutine从线程退出
runtime.Gosched()
}
} func main() {
wg.Add(2)
go addCount()
go addCount()
wg.Wait()
fmt.Printf("counter: %d\n",counter)
}
//output:
counter: 4

这里使用atomic.AddInt64函数来对一个整形数据进行加操作,另外一些有用的原子操作还有:

atomic.StoreInt64() //写
atomic.LoadInt64() //读

更多的原子操作函数请看atomic包中的声明。

3. 使用互斥锁

对临界区的访问,可以使用互斥锁来进行。对于example4.go的竞争状态,可以使用互斥锁来解决:

//example5.go
package main import (
"sync"
"runtime"
"fmt"
) var (
//counter为访问的资源
counter int
wg sync.WaitGroup
mutex sync.Mutex
) func addCount() {
defer wg.Done() for count := 0; count < 2; count++ {
//加上锁,进入临界区域
mutex.Lock()
{
value := counter
//当前goroutine从线程退出
runtime.Gosched()
value++
counter = value
}
//离开临界区,释放互斥锁
mutex.Unlock()
}
}
func main() {
wg.Add(2)
go addCount()
go addCount()
wg.Wait()
fmt.Printf("counter: %d\n", counter)
} //output:
counter: 4

使用Lock()Unlock()函数调用来定义临界区,在同一个时刻内,只有一个goroutine能够进入临界区,直到调用Unlock()函数后,其他的goroutine才能够进入临界区。

在Go中解决共享资源安全访问,更常用的使用通道chan。

三、利用通道共享数据

Go语言采用CSP消息传递模型。通过在goroutine之间传递数据来传递消息,而不是对数据进行加锁来实现同步访问。这里就需要用到通道chan这种特殊的数据类型。当一个资源需要在goroutine中共享时,chan在goroutine中间架起了一个通道。通道使用make来创建:

unbuffered := make(char int) //创建无缓存通道,用于int类型数据共享
buffered := make(chan string,10)//创建有缓存通道,用于string类型数据共享
buffered<- "hello world" //向通道中写入数据
value:= <-buffered //从通道buffered中接受数据

通道用于放置某一种类型的数据。创建通道时指定通道的大小,将创建有缓存的通道。无缓存通道是一种同步通信机制,它要求发送goroutine和接收goroutine都应该准备好,否则会进入阻塞。

1. 无缓存的通道

无缓存通道是同步的——一个goroutine向channel写入消息的操作会一直阻塞,直到另一个goroutine从通道中读取消息。反过来也是,一个goroutine从channel读取消息的操作会一直阻塞,直到另一个goroutine向通道中写入消息。《Go in action》中关于无缓存通道的解释有一个非常棒的例子:网球比赛。在网球比赛中,两位选手总是处在以下两种状态之一:要么在等待接球,要么在把球打向对方。球的传递可看为通道中数据传递。下面这段代码使用通道模拟了这个过程:

//example6.go
package main import (
"sync"
"fmt"
"math/rand"
"time"
) var wg sync.WaitGroup func player(name string, court chan int) {
defer wg.Done()
for {
//如果通道关闭,那么选手胜利
ball, ok := <-court
if !ok {
fmt.Printf("Player %s Won\n", name)
return
}
n := rand.Intn(100) //随机概率使某个选手Miss
if n%13 == 0 {
fmt.Printf("Player %s Missed\n", name)
//关闭通道
close(court)
return
}
fmt.Printf("Player %s Hit %d\n", name, ball)
ball++
//否则选手进行击球
court <- ball
}
} func main() {
rand.Seed(time.Now().Unix())
court := make(chan int)
//等待两个goroutine都执行完
wg.Add(2)
//选手1等待接球
go player("candy", court)
//选手2等待接球
go player("luffic", court)
//球进入球场(可以开始比赛了)
court <- 1
wg.Wait()
}
//output:
Player luffic Hit 1
Player candy Hit 2
Player luffic Hit 3
Player candy Hit 4
Player luffic Hit 5
Player candy Missed
Player luffic Won

2. 有缓存的通道

有缓存的通道是一种在被接收前能存储一个或者多个值的通道,它与无缓存通道的区别在于:无缓存的通道保证进行发送和接收的goroutine会在同一时间进行数据交换,有缓存的通道没有这种保证。有缓存通道让goroutine阻塞的条件为:通道中没有数据可读的时候,接收动作会被阻塞;通道中没有区域容纳更多数据时,发送动作阻塞。向已经关闭的通道中发送数据,会引发panic,但是goroutine依旧能从通道中接收数据,但是不能再向通道里发送数据。所以,发送端应该负责把通道关闭,而不是由接收端来关闭通道。

小结

  • goroutine被逻辑处理器执行,逻辑处理器拥有独立的系统线程与运行队列
  • 多个goroutine在一个逻辑处理器上可以并发执行,当机器有多个物理核心时,可通过多个逻辑处理器来并行执行。
  • 使用关键字 go 来创建goroutine。
  • 在Go中,竞争状态出现在多个goroutine试图同时去访问一个资源时。
  • 可以使用互斥锁或者原子函数,去防止竞争状态的出现。
  • 在go中,更好的解决竞争状态的方法是使用通道来共享数据。
  • 无缓冲通道是同步的,而有缓冲通道不是。

(完)

《Go in action》读后记录:Go的并发与并行的更多相关文章

  1. 《effective Go》读后记录

    一个在线的Go编译器 如果还没来得及安装Go环境,想体验一下Go语言,可以在Go在线编译器 上运行Go程序. 格式化 让所有人都遵循一样的编码风格是一种理想,现在Go语言通过gofmt程序,让机器来处 ...

  2. 《effective Go》读后记录:GO基础

    一个在线的Go编译器 如果还没来得及安装Go环境,想体验一下Go语言,可以在Go在线编译器 上运行Go程序. 格式化 让所有人都遵循一样的编码风格是一种理想,现在Go语言通过gofmt程序,让机器来处 ...

  3. WiscKey: Separating Keys from Values in SSD-Conscious Storage [读后整理]

    WiscKey: Separating Keys from Values in SSD-Conscious Storage WiscKey是一个基于LSM的KV存储引擎,特点是:针对SSD的顺序和随机 ...

  4. 新生 & 语不惊人死不休 —— 《无限恐怖》读后有感

    开篇声明,我博客中“小心情”这一系列,全都是日记啊随笔啊什么乱七八糟的.如果一不小心点进来了,不妨直接关掉.我自己曾经写过一段时间的日记,常常翻看,毫无疑问我的文笔是很差的,而且心情也是瞬息万变的.因 ...

  5. Code Complete 读后总结和新的扩展阅读计划

    Code Complete 读后总结和新的扩展阅读计划 用了一年时间终于将代码大全读完了,在这里做一个简单的总结,并安排下一阶段的扩展阅读计划. 1.选择代码大全作为我程序员职业入门的第一本书,我认为 ...

  6. 《Effective Objective-C 2.0》 读后总结

    感觉自己最近提升很慢了.然后去找了一些面试题看看.发现自己自大了.在实际开发中,让我解决bug.编写功能,我有自信可以完成.但是对项目更深层的思考,我却没有.为了能进到自己的目标BAT.也为了让自己更 ...

  7. 浏览器渲染原理笔记 --《How Browser Work》读后总结

    综述 之前使用ExtJS时遇到一个问题:为什么依次设置多个组件的可见性界面会卡顿?在了解HTML的dom操作相关内容的时候也好奇这个东西到底是怎么回事,然后尤其搞不懂CSS和Html分管样式和网页结构 ...

  8. 在.txt文件的首行写上.LOG后,后面每次对改文本文件进行编辑后,系统会自动在编辑内容后记录操作时间

    在.txt文件的首行写上.LOG后,后面每次对改文本文件进行编辑后,系统会自动在编辑内容后记录操作时间

  9. 深入理解java虚拟机读后总结(个人总结记录)

    1.jvm布局:   jdk1.6版本JVM布局分为:heap(堆),method(方法区),stack(虚拟机栈),native stack(本地方法栈),程序计数器共五大区域. 其中方法区包含运行 ...

随机推荐

  1. JavaScript在应用中的技巧(二)

    ==,===运算符和强制转换 先看个表达式: "1.0e0" == { valueOf: function() { return true; } }; 是的,这个结果可能有点出乎意 ...

  2. PowerBI入门 第三篇:报表设计技巧

    最近做了几个PowerBI报表,对PowerBI的设计有了更深的理解,对数据的塑形(sharp data),不仅可以在Data Source中实现,例如在TSQL查询脚本中,而且可以在PowerBI中 ...

  3. 搭建自己的CA服务 - OpenSSL CA 实战

    当前网络安全事故不断,如何提升系统安全性是一个系统上线之前必须考虑的重点DFx特性之一.在提升系统安全性的方法中, 给每个端口(通道)加上SSL协议是最通用和有效的一种. 使用SSL就必须要有证书,在 ...

  4. HTML canvas 笑脸

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  5. 如何在C++中产生随机数

    C++中没有自带的random函数,要实现随机数的生成就需要使用rand()和srand().不过,由于rand()的内部实现是用线性同余法做的,所以生成的并不是真正的随机数,而是在一定范围内可看为随 ...

  6. 使用properties配置文件为javabean注入属性值

    ①:实体类 package com.hts.entity; import java.io.Serializable; public class A implements Serializable{ p ...

  7. 201521123092《java程序设计》第三周学习总结

    #1. 本章学习总结 你对于本章知识的学习总结 #2. 书面作业 **Q1.  代码阅读 public class Test1 { private int i = 1;//这行不能修改 private ...

  8. 201521123119《Java程序设计》第1周学习总结

    1.本周学习总结    1.Java语言是一种多用途的语言.并发的语言.以类为基础,面向对象的语言. 2.Java比C++更加方便,有辅助输入,编写速度大大加快. 3.Java根据应用领域不同,区分为 ...

  9. 201521145048《Java程序设计》第11周学习总结

    1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多线程相关内容. 2. 书面作业 本次PTA作业题集多线程 Q1.互斥访问与同步访问 完成题集4-4(互斥访问)与4-5(同步访问) ...

  10. Java课程设计—学生成绩管理系统(201521123002 林楚虹)

    1. 团队课程设计博客链接 团队博客链接 2.个人责模块或任务说明 根据学生学号查找学生成绩 根据学生姓名(支持模糊匹配)查找学生成绩 用POI技术导出Excel文件 3.自己的代码提交记录截图 4. ...